asset-pocket 0.1

data/features/images.feature

@@ -0,0 +1,20 @@
+
+Feature: copy files from one directory to another
+
+    @files
+    Scenario: keep the directory tree
+        Given a file named "sources/a/one" with "1"
+        And a file named "sources/a/two" with "2"
+        And a file named "sources/b/three" with "3"
+        And a file named "sources/b/d/four" with "4"
+        When generate a pocket with:
+        """
+        files "generated/copied/" do
+            base "sources"
+            use "sources/**/*"
+        end
+        """
+        Then a file named "generated/copied/a/one" contains "1"
+        And a file named "generated/copied/a/two" contains "2"
+        And a file named "generated/copied/b/three" contains "3"
+        And a file named "generated/copied/b/d/four" contains "4"

data/features/javascripts.feature

@@ -0,0 +1,89 @@
+
+Feature: JavaScripts Pocket
+
+    @javascript
+    Scenario: combine several files just concat them
+        Given a file named "sources/foo.js" with "foo();"
+        And a file named "sources/bar.js" with "bar();"
+        When generate a pocket with:
+        """
+        js "generated/dest.js" do
+            use "sources/foo.js"
+            use "sources/bar.js"
+        end
+        """
+        Then a file named "generated/dest.js" contains "foo();bar();"
+
+    @javascript
+    Scenario: combine several files with a separator
+        Given a file named "sources/foo.js" with "foo();"
+        And a file named "sources/bar.js" with "bar();"
+        When generate a pocket with:
+        """
+        js "generated/dest.js" do
+            use "sources/foo.js"
+            use "sources/bar.js"
+
+            separator "|"
+        end
+        """
+        Then a file named "generated/dest.js" contains "foo();|bar();"
+
+
+    @javascript
+    Scenario: a pattern can be used to append files sorted by name
+        Given a file named "sources/a/a.js" with "1"
+        And a file named "sources/c/b.js" with "5"
+        And a file named "sources/a/b.js" with "2"
+        And a file named "sources/b/a.js" with "4"
+        And a file named "sources/a/c.js" with "3"
+        When generate a pocket with:
+        """
+        js "generated/everything.js" do
+            use "sources/**/*.js"
+        end
+        """
+        Then a file named "generated/everything.js" contains "12345"
+
+    @javascript
+    Scenario: a custom compressor can be defined in the configuration
+        Given a file named "sources/foo.js" with "foo"
+        And a file named "sources/bar.js" with "bar"
+        When generate a pocket with:
+        """
+        class UpperCompressor
+            def compress(content)
+                content.upcase
+            end
+        end
+
+        compressor :upper, :handler => UpperCompressor.new
+        js "generated/upper.js" do
+            compress :upper
+            use "sources/**/*.js"
+        end
+        """
+        Then a file named "generated/upper.js" contains "BARFOO"
+
+    @javascript
+    Scenario: compressors can receive parameters 
+        Given a file named "sources/foo.js" with "foo"
+        And a file named "sources/bar.js" with "bar"
+        When generate a pocket with:
+        """
+        class AppendContentCompressor
+            attr_accessor :extra
+            def compress(content)
+                content + extra
+            end
+        end
+
+        compressor :append, :handler => AppendContentCompressor.new
+        compressor :append, :extra => "baz"
+        js "generated/append.js" do
+            compress :append
+            use "sources/**/*.js"
+        end
+        """
+        Then a file named "generated/append.js" contains "barfoobaz"
+

data/features/rails.feature

@@ -0,0 +1,52 @@
+
+Feature: Rails integration
+    Rails views have a helper method sprite_tag to create a HTML tag which will
+    show the image.
+
+    The rake task pocket:update will generate the pocket.
+
+    @rails
+    Scenario: create a new application and define a pocket with some files
+        Given a rails application in a temporary directory
+        And a file named "app/views/css/a.css" with "1"
+        And a file named "app/views/css/b.css" with "2"
+        And the application has a pocket with:
+        """
+        css "public/stylesheets/application.css" do
+            use "app/views/css/*"
+            separator "\n"
+        end
+        """
+        When update the pocket
+        Then a file named "public/stylesheets/application.css" contains "1\n2"
+
+    @rails
+    Scenario: create a CSS sprite in a rails application
+        Given a rails application in a temporary directory
+        And a file named "app/views/images/first.png" with a random image of 10x20
+        And a file named "app/views/images/second.png" with a random image of 10x30
+        And the application has a pocket with:
+        """
+        css "public/stylesheets/sprites.css" do
+            sprite "icons" do
+                layout :vertical
+                use "app/views/images/*"
+            end
+        end
+        """
+        And the controller "foo" has a view "index" with:
+        """
+        <%= sprite_tag "icons/first" %>
+        generated HTML from rails
+        <%= sprite_tag "icons/second" %>
+        """
+        When update the pocket
+        Then the sprite "icons" is generated in "public/stylesheets/sprites.css"
+        And this sprite has 2 images
+        And this sprite is 10x50
+        And this sprite format is PNG
+        And this sprite has the image "first"
+        And this sprite has the image "second"
+        Then the page at "/foo/index" include "generated HTML from rails"
+        And this page has a tag matched with ".sprite-icons--first"
+        And this page has a tag matched with ".sprite-icons--second"

data/features/sass.feature

@@ -0,0 +1,69 @@
+
+Feature: Sass integration
+
+    @sass
+    Scenario: filenames ended with .scss are compiled with Sass
+        Given a file named "sources/foo.scss" with "$color: blue; div { span { color: $color; } }"
+        When generate a pocket with:
+        """
+        css "generated/base.css" do
+            use "sources/foo.scss"
+        end
+        """
+        Then a file named "generated/base.css" contains "div span {\n  color: blue; }\n"
+
+    @sass
+    Scenario: Sass options can be modified
+        Given a file named "sources/bar.scss" with "div { span { display: block; } }"
+        When generate a pocket with:
+        """
+        sass :style => :compressed
+        css "generated/compressed.css" do
+            use "sources/bar.scss"
+        end
+        """
+        Then a file named "generated/compressed.css" contains "div span{display:block}\n"
+
+    @sass
+    Scenario: multiple Sass sources can be loaded importing them
+        Given a file named "sources/one.scss" with "$color: blue;"
+        And a file named "sources/two.scss" with "$background: black;"
+        And a file named "sources/three.scss" with "$color: blue !default;"
+        And a file named "sources/final.scss" with "div { background: $background; color: $color; }"
+        When generate a pocket with:
+        """
+        sass :style => :compressed
+        sass "generated/compressed.css" do
+            import "sources/one.scss"
+            import "sources/two.scss"
+            import "sources/three.scss"
+            import "sources/final.scss"
+        end
+        """
+        Then a file named "generated/compressed.css" contains "div{background:black;color:blue}\n"
+
+    @sass
+    Scenario: a bundle can be created with previous bundles
+        Given a file named "sources/one.css" with "div {}"
+        And a file named "sources/two.css" with "span {}"
+        And a file named "sources/three.scss" with "div { span { display: block; } }"
+        When generate a pocket with:
+        """
+        css "generated/first.css" do
+            use "sources/one.css"
+            use "sources/two.css"
+
+            separator "\n"
+        end
+
+        sass :style => :compressed
+        css "generated/second.css" do
+            use "sources/three.scss"
+        end
+
+        css "generated/both.css" do
+            use "generated/first.css"
+            use "generated/second.css"
+        end
+        """
+        Then a file named "generated/both.css" contains "div {}\nspan {}div span{display:block}\n"

data/features/sprites.feature

@@ -0,0 +1,94 @@
+
+Feature: generate CSS sprites from the pocket
+
+    @sprites
+    Scenario: create a simple sprite with different images
+        Given a file named "images/a.png" with a random image of 10x10
+        And a file named "images/b.png" with a random image of 10x20
+        And a file named "images/c.png" with a random image of 20x20
+        When generate a pocket with:
+        """
+        css "sprites/css/first.css" do
+            sprite "all" do
+                layout :vertical
+                use "images/*"
+            end
+        end
+        """
+        Then the sprite "all" is generated in "sprites/css/first.css"
+        And this sprite has 3 images
+        And this sprite is 20x50
+        And this sprite format is PNG
+
+    @sprites
+    Scenario Outline: sprites can be generated with different layoutes
+        Given 20 random images at "images/<case>/firstNN.png" with a random image of 10x30
+        When generate a pocket with:
+        """
+        css "sprites/css/<case>.css" do
+            sprite "all-<case>" do
+                layout <layout>
+                use "images/<case>/*"
+            end
+        end
+        """
+        Then the sprite "all-<case>" is generated in "sprites/css/<case>.css"
+        And this sprite has 20 images
+        And this sprite is <size>
+        And this sprite format is PNG
+
+        Scenarios:
+            | case       | layout        | size   |
+            | vertical   | :vertical     | 10x600 |
+            | horizontal | :horizontal   | 200x30 |
+            | table      | :columns => 5 | 50x120 |
+
+    @sprites
+    Scenario: different formats create different sprites
+        Given a file named "images/a.png" with a random image of 10x10
+        And a file named "images/b.png" with a random image of 10x20
+        And a file named "images/c.gif" with a random image of 20x20
+        And 10 random images at "images/firstNN.jpeg" with a random image of 10x30
+        When generate a pocket with:
+        """
+        css "sprites/css/multiformat.css" do
+            sprite "multiformat" do
+                layout :vertical
+                use "images/*"
+            end
+        end
+        """
+        Then the sprite "multiformat" encoded in PNG is generated in "sprites/css/multiformat.css"
+        And this sprite has 2 images
+        And this sprite is 10x30
+        And the sprite "multiformat" encoded in GIF is generated in "sprites/css/multiformat.css"
+        And this sprite has 1 image
+        And this sprite is 20x20
+        And the sprite "multiformat" encoded in JPEG is generated in "sprites/css/multiformat.css"
+        And this sprite has 10 images
+        And this sprite is 10x300
+
+    @sprites
+    Scenario: the sprites can be generated using different quality values
+        Given a file named "images/a.jpeg" with a random image of 10x10
+        And a file named "images/b.jpeg" with a random image of 10x20
+        And a file named "images/c.jpeg" with a random image of 20x20
+        When generate a pocket with:
+        """
+        css "sprites/css/everything.css" do
+            sprite "best" do
+                layout :vertical
+                quality 100
+                use "images/*"
+            end
+
+            sprite "worst" do
+                layout :vertical
+                quality 1
+                use "images/*"
+            end
+        end
+        """
+        Then the sprite "worst" is generated in "sprites/css/everything.css"
+        And the sprite "best" is generated in "sprites/css/everything.css"
+        And the size of the sprite "worst" is smaller than the size of the sprite "best"

data/features/step_definitions/files.rb

@@ -0,0 +1,23 @@
+
+Given /^a file named "([^"]*)" with "([^"]*)"$/ do |filename, content|
+    filename = @temp_dir.join(filename)
+    filename.exist?.should be_false
+
+    @created_files.unshift filename
+    filename.dirname.mkpath
+    filename.open("w") {|f| f.write content }
+end
+
+When /^generate a pocket with:$/ do |pocket_content|
+    generator = AssetPocket::Generator.new
+    generator.root_path = @temp_dir
+    generator.parse_string pocket_content
+    generator.run!
+end
+
+Then /^a file named "([^"]*)" contains "([^"]*)"$/ do |filename, content|
+    filename = @temp_dir.join(filename)
+    filename.file?.should be_true
+    filename.read.inspect[1..-2].should eql(content)
+end
+

data/features/step_definitions/rails.rb

@@ -0,0 +1,78 @@
+
+Given /^a rails application in a temporary directory$/ do
+    @temp_dir = @temp_dir.join("test_pocket")
+    case (`rails -v` =~ /rails (\d+)/i && $1).to_i
+    when 3
+        `rails new #{@temp_dir}`
+        @temp_dir.join("config/initializers/rack_test.rb").open("w") {|f| f.puts <<-EOI }
+            RackTestApplication = proc { Rails::Application.instance }
+        EOI
+    when 2
+        `rails #{@temp_dir}`
+        @temp_dir.join("config/initializers/rack_test.rb").open("w") {|f| f.puts <<-EOI }
+            gem "rack-test"
+            require 'rack/test'
+            RackTestApplication = proc { ActionController::Dispatcher.new }
+
+            class String
+                def html_safe
+                    self
+                end
+            end
+        EOI
+    else
+        pending
+    end
+
+    plugin_dir = @temp_dir.join("vendor/plugins")
+    plugin_dir.mkpath
+    FileUtils.cp_r Pathname.new(__FILE__).dirname.join("../../"), plugin_dir
+end
+
+Given /^the application has a pocket with:$/ do |pocket|
+    pocket_file = @temp_dir.join("config/pocket.rb")
+    pocket_file.exist?.should be_false
+    pocket_file.open("w") {|f| f.write pocket }
+end
+
+Given /^the controller "([^"]*)" has a view "([^"]*)" with:$/ do |controller, action, erb|
+    controller_file = @temp_dir.join("app/controllers/#{controller}_controller.rb")
+    if not controller_file.exist?
+        controller_file.dirname.mkpath
+        controller_file.open("w") {|f| f.puts "class #{"#{controller}_controller".gsub(/(?:^|_)([a-z])/) { $1.upcase }} < ApplicationController\nend" }
+
+        # This route should works in both Rails 3 and 2
+        routes = @temp_dir.join("config/routes.rb")
+        current_routes = routes.read
+        routes.open("w") {|f| f.write current_routes.sub(/end\s*\Z/, %[map.connect "/#{controller}/:action", :controller => "#{controller}"\nend\n]) }
+    end
+
+    view_file = @temp_dir.join("app/views/#{controller}/#{action}.html.erb")
+    view_file.dirname.mkpath
+    view_file.open("w") {|f| f.write erb }
+end
+
+
+Then /^the page at "([^"]*)" include "([^"]*)"$/ do |uri,html|
+    if @temp_dir.join("script/rails").exist?
+        runner = "rails runner"
+    else
+        runner = "script/runner"
+    end
+
+    @page_body = `cd #{@temp_dir}; #{runner} 'puts Rack::Test::Session.new(RackTestApplication.call).get("#{uri}").body'`
+    @page_body.should include(html)
+end
+
+Then /^this page has a tag matched with "([^"]*)"$/ do |selector|
+    @page_dom ||= Nokogiri::HTML(@page_body)
+    @page_dom.search(selector).should_not be_empty
+end
+
+When /^update the pocket$/ do
+    Process.wait(fork do
+        Dir.chdir @temp_dir
+        STDOUT.reopen "/dev/null", "w"
+        exec "rake", "pocket:update"
+    end)
+end

data/features/step_definitions/sprites.rb

@@ -0,0 +1,76 @@
+
+def random_image(filename, width, height)
+    img = Magick::Image.new(width, height)
+    img.import_pixels 0, 0, width, height, "RGB", File.read("/dev/urandom", width*height*3)
+
+    filename = @temp_dir.join(filename)
+    filename.dirname.mkpath
+    img.write filename.to_s
+
+    @created_files.unshift filename if @created_files
+end
+
+Given /^(\d+) random images at "([^"]*)" with a random image of (\d+)x(\d+)$/ do |count, pattern, width, height|
+    width = width.to_i
+    height = height.to_i
+    count.to_i.times do |iter|
+        random_image pattern.sub("NN", iter.to_s), width, height
+    end
+end
+
+Given /^a file named "([^"]*)" with a random image of (\d+)x(\d+)$/ do |filename, width, height|
+    random_image filename, width.to_i, height.to_i
+end
+
+
+def just_parse_css(content)
+    content.scan(/(\S+)\s*\{(.*?)\}/m).inject({}) do |hash, item|
+        rule, attributes = item
+        hash[rule] = attributes.split(";").map {|attribute| attribute.strip }
+        hash
+    end
+end
+
+Then /^the sprite "([^"]*)" is generated in "([^"]*)"$/ do |sprite, css_file|
+    Then %|the sprite "#{sprite}" encoded in \\w+ is generated in "#{css_file}"|
+end
+
+Then /^the sprite "([^"]*)" encoded in (\S+) is generated in "([^"]*)"$/ do |sprite, format, css_file|
+
+    @found_sprites ||= {}
+
+    @sprite_name = sprite
+
+    css_file = @temp_dir.join(css_file)
+    @css_loaded = just_parse_css(css_file.read)
+    @css_loaded.should include_key(/\.sprite-#{sprite}--/)
+
+    @sprite = @css_loaded.reject {|key, value| key !~ /\.sprite-#{sprite}--/ or value.join !~ /url\([^)]+\.#{format}\)/i }
+    @image_sprite = Magick::Image.read(css_file.dirname.join(@sprite.values.to_s.first =~ /url\((.*?\.#{format})\)/i && $1).to_s).first
+
+    @found_sprites[sprite] = @image_sprite
+end
+
+Then /^this sprite has (\d+) images?$/ do |count|
+    @sprite.size.should eql(count.to_i)
+end
+
+Then /^this sprite is (\d+)x(\d+)$/ do |width, height|
+    @image_sprite.columns.should eql(width.to_i)
+    @image_sprite.rows.should eql(height.to_i)
+end
+
+Then /^this sprite format is (\S+)$/ do |format|
+    @image_sprite.format.downcase.should eql(format.downcase)
+end
+
+Then /^this sprite has the image "([^"]*)"$/ do |image_name|
+    @css_loaded.should include_key(/\.sprite-#{@sprite_name}--#{image_name}\b/)
+end
+
+Then /^the size of the sprite "([^"]*)" is smaller than the size of the sprite "([^"]*)"$/ do |big_sprite, small_sprite|
+    @found_sprites[big_sprite].should_not be_nil
+    @found_sprites[small_sprite].should_not be_nil
+    (@found_sprites[big_sprite].to_blob > @found_sprites[small_sprite].to_blob).should be_true
+end
+

data/features/support/env.rb

@@ -0,0 +1,37 @@
+
+require 'fileutils'
+require 'nokogiri'
+
+$: << File.expand_path("../../../lib/", __FILE__)
+require 'asset_pocket/generator'
+
+$temp_directory_count = 0
+def make_temp_directory
+    temp_dir = Pathname.new("/tmp/asset_pocket_test/t#$$/#{$temp_directory_count += 1}")
+    temp_dir.mkpath
+    temp_dir
+end
+
+class Pathname
+    def rmdir_when_empty
+        rmdir
+        true
+    rescue Errno::ENOTEMPTY
+        false
+    end
+end
+
+Before do
+    @created_files = []
+    @temp_dir = make_temp_directory
+
+    AssetPocket::SourceFilter::Sass.default_options[:cache_location] = @temp_dir.join("sass-cache").to_s
+end
+
+After do
+    @created_files.each do |filename|
+        filename.delete
+        filename.dirname.rmdir_when_empty
+    end
+end
+

data/features/support/matchers.rb

@@ -0,0 +1,6 @@
+
+def include_key(regexp)
+    simple_matcher("include a key that matchs #{regexp.inspect}") do |given|
+        given.keys.grep(regexp).size > 0
+    end
+end

data/lib/asset_pocket.rb

@@ -0,0 +1,4 @@
+
+if defined?(Rails)
+    require 'asset_pocket/rails'
+end

data/lib/asset_pocket/compressor.rb

@@ -0,0 +1,29 @@
+
+module AssetPocket
+    class Compressor
+
+        class Error < StandardError; end
+
+        class <<self
+            attr_accessor :available
+
+            def parse(name, options = {})
+                name = name.to_s
+                if not available.has_key?(name)
+                    if handler = options[:handler]
+                        available[name] = handler
+                    else
+                        raise Error, "Unknown compressor: #{name}"
+                    end
+                end
+
+                hanlder = available[name]
+                options.each_pair {|key, value| hanlder.send("#{key}=", value) unless key == :handler }
+
+                hanlder
+            end
+        end
+
+        self.available = {}
+    end
+end

data/lib/asset_pocket/css_sprites.rb

@@ -0,0 +1,141 @@
+
+require 'RMagick'
+require 'md5'
+
+module AssetPocket
+    class Pocket
+        class SpriteDefition
+            attr_accessor :layout, :quality
+            attr_reader :name, :css_block, :images_location
+
+            def initialize(name, css_block)
+                @name = name
+                @css_block = css_block
+                @files = {}
+                @layout = :vertical
+
+                self.images_location = "../images/"
+            end
+
+            def images_location=(location)
+                @images_location = css_block.pocket.generator.root_path.join(css_block.filename).dirname.join(location)
+            end
+
+            def generate!
+                @images_location.mkpath
+
+                @files.each_pair do |format, images|
+
+                    sprite_name = @images_location.join("sprite-#{name}.#{format.downcase}")
+                    url_css_sprite = sprite_name.relative_path_from(css_block.full_filename.dirname)
+
+                    # Compute the canvas size
+                    width = 0
+                    height = 0
+
+                    distribute_images images do |image, cx, cy|
+                        cx = cx + image.columns
+                        cy = cy + image.rows
+
+                        height = cy if cy > height
+                        width = cx if cx > width
+                    end
+
+                    canvas = Magick::Image.new(width, height)
+                    canvas.format = format
+
+                    distribute_images images do |image, cx, cy|
+                        canvas.composite! image, cx, cy, Magick::OverCompositeOp
+
+                        css = ".sprite.sprite-#{name}--#{File.basename(image.filename).gsub(/\.\w+$/, "")} {"
+                        css << "background: url(#{url_css_sprite}) -#{cx}px -#{cy}px;"
+                        css << "width: #{image.columns}px;"
+                        css << "height: #{image.rows}px;"
+                        css << "} \n"
+                        css_block.content << [ :string, css]
+                    end
+
+                    images.clear
+                    quality = quality() # Force variable creation. Block passed to canvas.write losses instance reference (called with instance_eval?)
+                    canvas.write(sprite_name.to_s) do |info|
+                        info.quality = quality if quality
+                    end
+                end
+            end
+
+            def use(pattern)
+                @files ||= []
+                Dir[css_block.pocket.generator.root_path.join(pattern)].each do |image_file|
+                    begin
+                        image = Magick::Image.read(image_file)
+                        if image.size != 1
+                            # Animated images can not be sprited
+                            # TODO log the action
+                            next
+                        end
+
+                        image = image.first
+
+                    rescue Magick::ImageMagickError
+                        # TODO log the error
+                        next
+                    end
+
+                    @files[image.format] ||= []
+                    @files[image.format] << image
+                end
+            end
+
+        private
+            def distribute_images(images, &block)
+                cx = cy = 0
+                valid_layout = true
+
+                case layout
+                when :vertical
+                    images.each do |image|
+                        block.call image, cx, cy
+                        cy += image.rows
+                    end
+
+                when :horizontal
+                    images.each do |image|
+                        block.call image, cx, cy
+                        cx += image.columns
+                    end
+
+                when Hash
+                    if layout[:columns]
+                        column = 0
+                        row_height = 0
+                        columns_per_row = layout[:columns]
+
+                        images.each do |image|
+                            column += 1
+                            if column > columns_per_row
+                                column = 1
+                                cx = 0
+                                cy += row_height
+                                row_height = 0
+                            end
+
+                            block.call image, cx, cy
+                            cx += image.columns
+                            row_height = image.rows if image.rows > row_height
+                        end
+
+                    else
+                        valid_layout = false
+                    end
+
+                else
+                    valid_layout = false
+                end
+
+                unless valid_layout
+                    raise ArgumentError, "Unknown layout: #{layout} in sprite #{name}"
+                end
+            end
+        end
+    end
+end

data/lib/asset_pocket/generator.rb

@@ -0,0 +1,107 @@
+
+require 'asset_pocket/pocket'
+require 'asset_pocket/source_filter'
+require 'fileutils'
+require 'pathname'
+
+module AssetPocket
+    class Generator
+        attr_reader :root_path
+
+        def initialize
+            self.root_path = "."
+            @pocket = nil
+        end
+
+        def root_path=(path)
+            @root_path = Pathname.new(path.to_s)
+        end
+
+        def parse_string(content)
+            @pocket = Pocket.new(self)
+            @pocket.parse_string content
+        end
+
+        def read_file(filename)
+            root_path.join(filename).read
+        end
+
+        def run!
+            @pocket.definitions.each do |definition|
+                send "process_#{definition.process}", definition
+            end
+            true
+        end
+
+        def process_create_file(definition)
+            generated_filename = root_path.join(definition.filename)
+            FileUtils.mkpath File.dirname(generated_filename)
+            File.open(generated_filename, "w") do |generated_file|
+                generated_content = []
+                definition.content.each do |content|
+                    case content[0]
+                    when :pattern
+                        generated_content.concat(
+                            Dir[root_path.join(content[1])].
+                                sort!.
+                                map! {|found_file| SourceFilter.filter found_file })
+
+                    when :string
+                        generated_content << content[1]
+
+                    else
+                        raise ArgumentError, "Unknown content type: #{content[0]}"
+                    end
+                end
+
+                generated_content = generated_content.join(definition.separator)
+
+                if definition.use_compressor?
+                    generated_content = definition.compressor.compress(generated_content)
+                end
+
+                generated_content = definition.post_process(generated_content)
+                generated_file.write(generated_content)
+            end
+        end
+
+        def process_copy_files(definition)
+            base = Pathname.new(File.expand_path(definition.base, root_path))
+            dest_dir = root_path.join(definition.filename)
+            dest_dir.mkpath
+
+            definition.content.each do |content|
+                case content[0]
+                when :pattern
+                    Dir[root_path.join(content[1])].each do |source_file|
+                        source_file = Pathname.new(source_file)
+
+                        # Only work with regular file
+                        next unless source_file.file?
+
+                        dest_file = dest_dir.join(source_file.relative_path_from(base))
+
+                        if dest_file.exist?
+                            # Compare it using timestamps and size
+                            if source_file.size == dest_file.size and source_file.mtime == dest_file.mtime
+                                next
+                            end
+
+                            # Remove it, since we have to recreate
+                            dest_file.delete
+                        end
+
+                        # Try to create a hard link (Unix on same mount points).
+                        # If it fails, copy it
+                        dest_file.dirname.mkpath
+                        begin
+                            dest_file.make_link source_file
+                        rescue Exception => e
+                            dest_file.open("w") {|f| f.write source_file.read }
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/asset_pocket/pocket.rb

@@ -0,0 +1,165 @@
+
+require 'asset_pocket/compressor'
+require 'asset_pocket/css_sprites'
+
+module AssetPocket
+    class Pocket
+
+        attr_reader :definitions, :generator
+
+        def initialize(generator)
+            @generator = generator
+            @definitions = []
+        end
+
+        def parse_string(content)
+            instance_eval content
+        end
+
+        def compressor(name, options = {})
+            AssetPocket::Compressor.parse name, options
+        end
+
+        def sass(option = {}, &block)
+            case option
+            when Hash
+                SourceFilter::Sass.default_options.merge! option
+            when String
+                defs = SassDefinitions.new(self, option)
+                defs.instance_eval(&block)
+                definitions << defs
+            else
+                raise ArgumentError, "Unknown argument type: #{options.class}"
+            end
+        end
+
+        def css(filename, &block)
+            defs = CSSDefinitions.new(self, filename)
+            defs.instance_eval(&block)
+            definitions << defs
+        end
+
+        def js(filename, &block)
+            defs = JSDefinitions.new(self, filename)
+            defs.instance_eval(&block)
+            definitions << defs
+        end
+
+        def files(dirname, &block)
+            defs = FilesDefinitions.new(self, dirname)
+            defs.instance_eval(&block)
+            definitions << defs
+        end
+
+        class Definitions
+            attr_reader :content, :compressor, :filename, :pocket
+
+            def initialize(pocket, filename)
+                @pocket = pocket
+                @content = []
+                @filename = filename
+                @compressor = nil
+                @separator = ""
+            end
+
+            def full_filename
+                pocket.generator.root_path.join filename
+            end
+
+            def process
+                :create_file
+            end
+
+            def use_compressor?
+                @compressor
+            end
+
+            def use(pattern)
+                @content << [ :pattern, pattern ]
+            end
+
+            def compress(name, options = {})
+                @compressor = AssetPocket::Compressor.parse name, options
+            end
+
+            def separator(new_value = nil)
+                @separator = new_value unless new_value.nil?
+                @separator
+            end
+
+            def post_process(generated_content)
+                generated_content
+            end
+
+        end
+
+        class CSSDefinitions < Definitions
+
+            def sprite(name, &block)
+                @current_sprite = SpriteDefition.new(name, self)
+                block.call
+                @current_sprite.generate!
+            ensure
+                @current_sprite = nil
+            end
+
+            def layout(value)
+                ensure_sprite!
+                @current_sprite.layout = value
+            end
+
+            def images_location(value)
+                ensure_sprite!
+                @current_sprite.images_location = value
+            end
+
+            def quality(value)
+                ensure_sprite!
+                @current_sprite.quality = value
+            end
+
+            def use(pattern)
+                if @current_sprite
+                    @current_sprite.use pattern
+                else
+                    super
+                end
+            end
+
+        private
+            def ensure_sprite!
+                raise NameError, "this macro has to be used in a sprite block" if @current_sprite.nil?
+            end
+        end
+
+        class JSDefinitions < Definitions
+        end
+
+        class SassDefinitions < Definitions
+            def import(filename)
+                @content << [ :string, "@import \"#{File.expand_path(filename, pocket.generator.root_path)}\";\n" ]
+            end
+
+            def post_process(generated_content)
+                SourceFilter::Sass.render("#{filename}.scss", generated_content)
+            end
+
+            undef_method :use
+        end
+
+        class FilesDefinitions < Definitions
+            def process
+                :copy_files
+            end
+
+            def base(value = nil)
+                @base = value if value
+                @base || "."
+            end
+
+            undef_method :separator
+            undef_method :compress
+        end
+
+    end
+end

data/lib/asset_pocket/rails.rb

@@ -0,0 +1,15 @@
+
+module AssetPocket
+    module ViewHelperMethods
+        def sprite_tag(name, options = {})
+            # TODO options: tag_name, :class, :style, something like that
+            # TODO Generate the CSS class name inside AssetPocket, and not hardcoded
+            group, image = name.split("/")
+            %[<span class="sprite-#{group}--#{image}">&nbsp;</span>].html_safe
+        end
+    end
+end
+
+ActionView::Base.class_eval do
+    include AssetPocket::ViewHelperMethods
+end

data/lib/asset_pocket/source_filter.rb

@@ -0,0 +1,52 @@
+
+module AssetPocket
+    module SourceFilter
+        extend self
+
+        module Sass
+            extend self
+
+            attr_accessor :default_options
+            self.default_options = {
+                 :css_location => "./tmp/sass-cache"
+            }
+
+            def render(filename, content)
+                options = { :filename => filename }.merge(default_options)
+
+                if filename =~ /\.sass$/i
+                    options[:syntax] = :sass
+                elsif filename =~ /\.scss$/i
+                    options[:syntax] = :scss
+                else
+                    return content
+                end
+
+                require 'sass' # Load only when needed
+
+                begin
+                    ::Sass::Engine.new(content, options).render
+
+                rescue ::Sass::SyntaxError => error
+                    "/* #{File.basename(filename)}: #{error.to_s.gsub("*/", "* /")} */"
+                end
+            end
+        end
+
+        Filters = [
+            [ /.*\.s[ac]ss$/i, Sass.method(:render) ]
+        ]
+
+        def filter(filename)
+            content = File.read filename
+
+            Filters.each do |filter|
+                if filename =~ filter[0]
+                    return filter[1].call filename, content
+                end
+            end
+
+            content
+        end
+    end
+end

data/lib/tasks/pocket.rake

@@ -0,0 +1,12 @@
+
+namespace :pocket do
+
+    desc "Update the pocket using AssetPocket"
+    task :update => :environment do
+        require 'asset_pocket/generator'
+        generator = AssetPocket::Generator.new
+        generator.root_path = Rails.root
+        generator.parse_string Rails.root.join("config/pocket.rb").read
+        generator.run!
+    end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'asset_pocket/rails'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: asset-pocket
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Ayose Cazorla
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-17 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Using a config file (pocket) you can create multiple kind of assets groups
+email: setepo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- features/support/matchers.rb
+- features/support/env.rb
+- features/step_definitions/files.rb
+- features/step_definitions/rails.rb
+- features/step_definitions/sprites.rb
+- features/rails.feature
+- features/images.feature
+- features/sass.feature
+- features/javascripts.feature
+- features/sprites.feature
+- lib/asset_pocket/pocket.rb
+- lib/asset_pocket/css_sprites.rb
+- lib/asset_pocket/source_filter.rb
+- lib/asset_pocket/compressor.rb
+- lib/asset_pocket/generator.rb
+- lib/asset_pocket/rails.rb
+- lib/asset_pocket.rb
+- lib/tasks/pocket.rake
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/setepo/asset_pocket
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Manages assets in a versatile way
+test_files: []
+