asset_library 0.4.0 → 0.5.0

data/README.rdoc

@@ -58,63 +58,66 @@ A cached module is simply the concatenation of its constituent files.
 A typical configuration (Yaml) file might look like this. In Rails, this
 should be in <tt>config/asset_library.yml</tt>.
 
-  javascripts:
-    cache: library
-    optional_suffix: compressed
-    base: javascripts
-    suffix: js
-    files:
-      - vendor/jquery
-
-      # jQuery UI parts we need
-      - vendor/jquery-ui/ui.core
-      - vendor/jquery-ui/ui.draggable
-      - vendor/jquery-ui/ui.droppable
-      - vendor/jquery-ui/ui.sortable
-      - vendor/jquery-ui/effects.core
-
-      - lib
-      - plugins/*
-      - application
-      - initializers/*
-
-  tiny_mce_javascripts:
-    # TinyMCE doesn't give us a choice on cache name
-    cache: vendor/tiny_mce/tiny_mce_gzip
-    optional_suffix: compressed
-    base: javascripts
-    suffix: js
-    files:
-      - vendor/tiny_mce/tiny_mce
-      # ... it's possible to bundle all of TinyMCE together with a bit of magic
-
-  stylesheets:
-    cache: library
-    base: stylesheets
-    suffix: css
-    formats:
-      - ie6: [null, ie8, ie7, ie6]
-      - ie7: [null, ie8, ie7]
-      - ie8: [null, ie8]
-    files:
-      - reset
-      - application
-      - layout
-      - views/**/*
+  modules:
+    javascripts:
+      cache: library
+      optional_suffix: compressed
+      base: javascripts
+      suffix: js
+      files:
+        - vendor/jquery
+
+        # jQuery UI parts we need
+        - vendor/jquery-ui/ui.core
+        - vendor/jquery-ui/ui.draggable
+        - vendor/jquery-ui/ui.droppable
+        - vendor/jquery-ui/ui.sortable
+        - vendor/jquery-ui/effects.core
+
+        - lib
+        - plugins/*
+        - application
+        - initializers/*
+
+    tiny_mce_javascripts:
+      # TinyMCE doesn't give us a choice on cache name
+      cache: vendor/tiny_mce/tiny_mce_gzip
+      optional_suffix: compressed
+      base: javascripts
+      suffix: js
+      files:
+        - vendor/tiny_mce/tiny_mce
+        # ... it's possible to bundle all of TinyMCE together with a bit of magic
+
+    stylesheets:
+      cache: library
+      base: stylesheets
+      suffix: css
+      formats:
+        - ie6: [null, ie8, ie7, ie6]
+        - ie7: [null, ie8, ie7]
+        - ie8: [null, ie8]
+      files:
+        - reset
+        - application
+        - layout
+        - views/**/*
 
   # in general...
-  #module_name:
-  #  cache: cache_file
-  #  base: base_path_of_assets_in_web_root
-  #  suffix: suffix ("css" or "js")
-  #  formats:
-  #    format1: ["extra_suffix_1", "extra_suffix_2"]
-  #    format2: [null, "extra_suffix3"]
-  #  optional_suffix: optional_suffix
-  #  files:
-  #    - file1_relative_to_base
-  #    - file2_relative_to_base
-  #    - ...
+  # modules:
+  #   module_name:
+  #     cache: cache_file
+  #     base: base_path_of_assets_in_web_root
+  #     suffix: suffix ("css" or "js")
+  #     formats:
+  #       format1: ["extra_suffix_1", "extra_suffix_2"]
+  #       format2: [null, "extra_suffix3"]
+  #     optional_suffix: optional_suffix
+  #     files:
+  #       - file1_relative_to_base
+  #       - file2_relative_to_base
+  #       - ...
+  #   ...
 
 Here are what the various configuration elements mean:
 
@@ -160,6 +163,51 @@ not exist will be excluded; globbing will include/exclude files with
 <tt>formats</tt> as appropriate; and files without <tt>optional_suffix</tt>
 will not be output alongside files with the same name endowed with the suffix.
 
+== Compilers
+
+If you would like asset library to do more than just concatenate the
+files to produce your modules, then you need to specify a compiler.
+Asset Library currently ships with support for one compiler: Closure
+Compiler, and has an extendable framework to add more.
+
+To specify that a module is to be compiled with the Closure Compiler,
+use the <tt>compiler</tt> key for that module.  You may pass
+additional flags with the <tt>compiler_flags</tt> option:
+
+    modules:
+      javascripts:
+        cache: library
+        compiler: closure
+        compiler_flags: --warning_level QUIET
+        base: javascripts
+        suffix: js
+        files:
+          - javascripts/**/*
+
+You also need to configure the compiler by using a
+<tt>compilers.closure</tt> key:
+
+    compilers:
+      closure:
+        path: /path/to/closure.jar
+        flags: --warning_level QUIET
+
+The full list of Closure Compiler settings are:
+
+<tt>path</tt>: The path to the Closure Compiler jar.  This is
+mandatory.
+
+<tt>flags</tt>: Flags to pass to Closure Compiler.  These are combined
+with any per-module flags given via the <tt>compiler_flags</tt> option
+in the individual modules.  Default: no flags.
+
+<tt>java</tt>: The java command to use.  This will be searched for in
+the <tt>PATH</tt> unless it is an absolute filename.  Default:
+<tt>java</tt>.
+
+<tt>java_flags</tt>: Flags to pass to the java interpreter.  Default:
+no flags.
+
 == Copyright
 
 I believe in software freedom, not any abomination thereof. This project is

data/lib/asset_library/asset_module.rb

@@ -4,10 +4,23 @@ class AssetLibrary
   class AssetModule
     attr_reader(:config)
 
-    def initialize(config)
+    def initialize(name, config)
+      @name = name.to_s
       @config = config
     end
 
+    attr_reader :name
+
+    # Returns the type of compiler to use for this asset module.
+    def compiler_type
+      (config[:compiler] || :default).to_sym
+    end
+
+    # Returns the Array of compiler flags to use.
+    def compiler_flags
+      Util.normalize_flags(config[:compiler_flags])
+    end
+
     # Returns an Array of Assets to include.
     #
     # Arguments:
@@ -49,36 +62,10 @@ class AssetLibrary
       extra_suffixes.inject([]) { |r, s| r.concat(assets_with_extra_suffix(s)) }
     end
 
-    def contents(format = nil)
-      s = StringIO.new
-
-      assets(format).each do |asset|
-        File.open(asset.absolute_path, 'r') do |infile|
-          s.write(infile.read)
-        end
-      end
-      s.rewind
-
-      s
-    end
-
     # Returns an Asset representing the cache file
     def cache_asset(format = nil)
       extra = format ? ".#{format}" : ''
       Asset.new(File.join(AssetLibrary.root, config[:base], "#{config[:cache]}#{extra}.#{config[:suffix]}"))
     end
-
-    def write_cache(format = nil)
-      File.open(cache_asset(format).absolute_path, 'w') do |outfile|
-        outfile.write(contents(format).read)
-      end
-    end
-
-    def write_all_caches
-      write_cache
-      (config[:formats] || {}).keys.each do |format|
-        write_cache(format)
-      end
-    end
   end
 end

data/lib/asset_library/compiler/base.rb

@@ -0,0 +1,32 @@
+class AssetLibrary
+  module Compiler
+    class Base
+      def initialize(config)
+        @config = config || {}
+        @asset_modules = []
+      end
+
+      attr_reader :config, :asset_modules
+
+      def add_asset_module(asset_module)
+        @asset_modules << asset_module
+      end
+
+      def write_all_caches(format = nil)
+        raise NotImplementedError, "abstract method"
+      end
+
+      protected
+
+      # Return the absolute output path for the given asset module.
+      def output_path(asset_module, format)
+        asset_module.cache_asset(format).absolute_path
+      end
+
+      # Return the absolute input paths for the given asset module.
+      def input_paths(asset_module, format)
+        asset_module.assets(format).map{|asset| asset.absolute_path}
+      end
+    end
+  end
+end

data/lib/asset_library/compiler/closure.rb

@@ -0,0 +1,39 @@
+require 'tmpdir'
+
+class AssetLibrary
+  module Compiler
+    class Closure < Base
+      def initialize(config)
+        super
+        config[:path] or
+          raise ConfigurationError, "Please set path of closure jar with compilers.closure.path configuration setting"
+        config[:java] ||= 'java'
+        config[:java_flags] = Util.normalize_flags(config[:java_flags])
+        config[:path] = normalize_path(config[:path])
+        config[:flags] = Util.normalize_flags(config[:flags])
+      end
+
+      def write_all_caches(format = nil)
+        asset_modules.each do |asset_module|
+          command = [config[:java]]
+          command.concat(config[:java_flags])
+          command << '-jar' << config[:path]
+          command.concat(config[:flags])
+          command.concat(asset_module.compiler_flags)
+          command << '--js_output_file' << "#{output_path(asset_module, format)}"
+          input_paths(asset_module, format).each do |input|
+            command << '--js' << input
+          end
+          system *command or
+            raise Error, "closure compiler failed"
+        end
+      end
+
+      private
+
+      def normalize_path(path)
+        (Pathname(AssetLibrary.app_root) + path).to_s
+      end
+    end
+  end
+end

data/lib/asset_library/compiler/default.rb

@@ -0,0 +1,15 @@
+class AssetLibrary
+  module Compiler
+    class Default < Base
+      def write_all_caches(format = nil)
+        asset_modules.each do |asset_module|
+          open(output_path(asset_module, format), 'w') do |file|
+            input_paths(asset_module, format).each do |path|
+              file << File.read(path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asset_library/compiler.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/compiler/base'
+require File.dirname(__FILE__) + '/compiler/default'
+require File.dirname(__FILE__) + '/compiler/closure'
+
+class AssetLibrary
+  module Compiler
+    Error = Class.new(RuntimeError)
+
+    class << self
+      # Create an instance of a compiler for the given compiler type.
+      def create(type, config={})
+        klass = compiler_classes[type] ||= built_in_class_for(type)
+        klass.new(config)
+      end
+
+      # Register a custom compiler class.
+      def register(type, klass)
+        compiler_classes[type] = klass
+      end
+
+      def reset!
+        compiler_classes.clear
+      end
+
+      private
+
+      def compiler_classes
+        @compiler_classes ||= {}
+      end
+
+      def built_in_class_for(type)
+        class_name = type.to_s.gsub(/(?:\A|_)(.)/){$1.upcase}
+        const_get(class_name)
+      end
+    end
+  end
+end

data/lib/asset_library/helpers.rb

@@ -1,3 +1,5 @@
+require 'enumerator'
+
 class AssetLibrary
   module Helpers
     def asset_library_javascript_tags(module_key, format = nil)

data/lib/asset_library/rake_tasks.rb

@@ -2,8 +2,9 @@ def init_asset_library
   require 'asset_library'
 
   # TODO: Find a way to not-hard-code these paths?
-  AssetLibrary.config_path = File.join(RAILS_ROOT, 'config', 'asset_library.yml')
-  AssetLibrary.root = File.join(RAILS_ROOT, 'public')
+  AssetLibrary.config_path = Rails.root + 'config/asset_library.yml'
+  AssetLibrary.root = Rails.public_path
+  AssetLibrary.app_root = Rails.root
 end
 
 namespace(:asset_library) do
@@ -16,10 +17,6 @@ namespace(:asset_library) do
   desc "Deletes all asset caches specified in config/asset.yml"
   task(:clean) do
     init_asset_library
-    keys = AssetLibrary.config.keys
-    asset_modules = keys.collect{|k| AssetLibrary.asset_module(k)}
-    asset_modules.each do |m|
-      FileUtils.rm_f(m.cache_asset.absolute_path)
-    end
+    AssetLibrary.delete_all_caches
   end
 end

data/lib/asset_library/util.rb

@@ -1,10 +1,25 @@
+require 'shellwords'
+
 class AssetLibrary
   module Util
-    def self.symbolize_hash_keys(hash)
-      return hash unless Hash === hash # because we recurse
-      hash.inject({}) do |ret, (key, value)|
-        ret[(key.to_sym rescue key) || key] = symbolize_hash_keys(value)
-        ret
+    class << self
+      def symbolize_hash_keys(hash)
+        return hash unless Hash === hash # because we recurse
+        hash.inject({}) do |ret, (key, value)|
+          ret[(key.to_sym rescue key) || key] = symbolize_hash_keys(value)
+          ret
+        end
+      end
+
+      def normalize_flags(flags)
+        case flags
+        when String
+          Shellwords.shellwords(flags)
+        when nil
+          []
+        else
+          flags
+        end
       end
     end
   end

data/lib/asset_library.rb

@@ -5,10 +5,14 @@ rescue LoadError
   require 'glob_fu'
 end
 
+require 'yaml'
+require File.dirname(__FILE__) + '/asset_library/compiler'
 require File.dirname(__FILE__) + '/asset_library/asset_module'
 require File.dirname(__FILE__) + '/asset_library/util'
 
 class AssetLibrary
+  ConfigurationError = Class.new(RuntimeError)
+
   class << self
     def config_path
       @config_path
@@ -18,13 +22,20 @@ class AssetLibrary
       @config_path = config_path
     end
 
-    def root
-      @root
-    end
+    #
+    # Root of your application.
+    #
+    # Paths of external programs (if required) are resolved relative
+    # to this path.
+    #
+    attr_accessor :app_root
 
-    def root=(root)
-      @root = root
-    end
+    #
+    # Root directory of your output files.
+    #
+    # Output files are resolved relative to this path.
+    #
+    attr_accessor :root
 
     def cache
       return true if @cache.nil?
@@ -32,8 +43,7 @@ class AssetLibrary
     end
 
     def cache=(cache)
-      @config = nil
-      @cache_vars = nil
+      reset!
       @cache = cache
     end
 
@@ -50,22 +60,62 @@ class AssetLibrary
       else
         {}
       end
+      if !ret[:modules] && ret.values.any?{|value| value.is_a?(Hash) && value[:files]}
+        warn <<-EOS.gsub(/^ *\|/, '')
+          |  WARNING: Your asset library configuration follows a
+          |  deprecated format.  Please move all your asset modules
+          |  under a "modules:" key, as described in the
+          |  documentation.
+        EOS
+        ret = { :modules => ret }
+      end
+      ret[:modules] ||= {}
+      ret[:compilers] ||= {}
       @config = cache ? ret : nil
       ret
     end
 
+    def compilers
+      @compilers ||= {}
+    end
+
     def asset_module(key)
-      module_config = config[key.to_sym]
+      module_config = config[:modules][key.to_sym]
       if module_config
-        AssetModule.new(module_config)
+        AssetModule.new(key, module_config)
       end
     end
 
+    def compiler(asset_module)
+      type = asset_module.compiler_type
+      config = self.config[:compilers][type] || {}
+      compilers[type] ||= Compiler.create(type, config)
+    end
+
     def write_all_caches
-      config.keys.each do |key|
+      config[:modules].keys.each do |key|
         m = asset_module(key)
-        m.write_all_caches
+        c = compiler(m)
+        c.add_asset_module(m)
       end
+
+      compilers.values.each do |compiler|
+        compiler.write_all_caches
+      end
+    end
+
+    def delete_all_caches
+      asset_modules = config[:modules].keys.collect{|k| AssetLibrary.asset_module(k)}
+      asset_modules.each do |m|
+        FileUtils.rm_f(m.cache_asset.absolute_path)
+      end
+    end
+
+    def reset!
+      @config = nil
+      @cache_vars = nil
+      @compilers = nil
+      Compiler.reset!
     end
   end
 end

data/rails/init.rb

@@ -1,3 +1,4 @@
 AssetLibrary.cache = ActionController::Base.perform_caching
-AssetLibrary.config_path = File.join(RAILS_ROOT, 'config', 'asset_library.yml')
-AssetLibrary.root = File.join(RAILS_ROOT, 'public')
+AssetLibrary.config_path = Rails.root + 'config/asset_library.yml'
+AssetLibrary.root = Rails.public_path
+AssetLibrary.app_root = Rails.root

data/spec/asset_library/asset_module_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 require 'set'
 
@@ -110,18 +110,6 @@ describe(AssetLibrary::AssetModule) do
     end
   end
 
-  describe('#contents') do
-    it('should return an IO object') do
-      stub_fs([ '/c/file1.css', '/c/file2.css' ])
-      m(css_config(:files => ['file*'])).contents.should(respond_to(:read))
-    end
-
-    it('should concatenate individual file contents') do
-      stub_fs([ '/c/file1.css', '/c/file2.css' ])
-      m(css_config(:files => ['file*'])).contents.read.should == "/c/file1.css\n/c/file2.css\n"
-    end
-  end
-
   describe('#cache_asset') do
     it('should use options[:cache]') do
       m(css_config).cache_asset.absolute_path.should == "#{prefix}/c/cache.css"
@@ -132,44 +120,10 @@ describe(AssetLibrary::AssetModule) do
     end
   end
 
-  describe('#write_cache') do
-    it('should write to cache.css') do
-      File.should_receive(:open).with("#{prefix}/c/cache.css", 'w')
-      m(css_config).write_cache
-    end
-
-    it('should write cache contents to cache') do
-      stub_fs([ '/c/file1.css', '/c/file2.css' ])
-      m(css_config(:files => ['file*'])).write_cache
-      File.open("#{prefix}/c/cache.css") { |f| f.read.should == "/c/file1.css\n/c/file2.css\n" }
-    end
-
-    it('should use :format to determine CSS output file') do
-      File.should_receive(:open).with("#{prefix}/c/cache.e.css", 'w')
-      m(css_config).write_cache(:e)
-    end
-  end
-
-  describe('#write_all_caches') do
-    it('should write cache.css (no :format)') do
-      File.should_receive(:open).with("#{prefix}/c/cache.css", 'w')
-      m(css_config).write_all_caches
-    end
-
-    it('should write no-format and all format files') do
-      formats = { :e1 => [], :e2 => [] }
-      File.should_receive(:open).with("#{prefix}/c/cache.css", 'w')
-      formats.keys.each do |format|
-        File.should_receive(:open).with("#{prefix}/c/cache.#{format}.css", 'w')
-      end
-      m(css_config(:formats => formats)).write_all_caches
-    end
-  end
-
   private
 
   def m(config)
-    AssetLibrary::AssetModule.new(config)
+    AssetLibrary::AssetModule.new(:name, config)
   end
 
   def js_config(options = {})

data/spec/asset_library/asset_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 require File.dirname(__FILE__) + '/../../lib/asset_library/asset'
 

data/spec/asset_library/compiler/base_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe(AssetLibrary::Compiler::Base) do
+  describe('#write_all_caches') do
+    it('should raise NotImplementedError') do
+      lambda do
+        AssetLibrary::Compiler::Base.new({}).write_all_caches
+      end.should raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/asset_library/compiler/closure_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe(AssetLibrary::Compiler::Closure) do
+  include TemporaryDirectory
+  include CompilerHelpers
+
+  before do
+    AssetLibrary.app_root = "#{tmp}/app_root"
+    AssetLibrary.root = "#{tmp}/root"
+  end
+
+  def compiler(configuration = {})
+    configuration[:path] = '/PATH/TO/CLOSURE.jar' unless configuration.key?(:path)
+    compiler = AssetLibrary::Compiler::Closure.new(configuration)
+    compiler.stub!(:system)
+    compiler
+  end
+
+  def add_one_compilation(compiler)
+    compiler.add_asset_module mock_asset_module('lib', :format, 'out.js', 'in.js')
+  end
+
+  describe('#initialize') do
+    it('should cry if the path to the compiler is not set') do
+      lambda{compiler(:path => nil)}.should raise_error(AssetLibrary::ConfigurationError)
+    end
+  end
+
+  describe('#write_all_caches') do
+    before do
+      @tmpdir = "#{tmp}/tmpdir"
+      FileUtils.mkdir_p @tmpdir
+      AssetLibrary::Util.stub!(:mktmpdir).and_yield(@tmpdir)
+    end
+
+    it("should run each module's files through closure compiler") do
+      compiler = self.compiler
+      compiler.add_asset_module mock_asset_module('lib1', :format, 'LIB1.js', 'lib1-file1.js')
+      compiler.add_asset_module mock_asset_module('lib2', :format, 'LIB2.js', 'lib2-file1.js', 'lib2-file2.js')
+      compiler.should_receive(:system).with(*%W"java -jar /PATH/TO/CLOSURE.jar --js_output_file LIB1.js --js lib1-file1.js").and_return(true)
+      compiler.should_receive(:system).with(*%W"java -jar /PATH/TO/CLOSURE.jar --js_output_file LIB2.js --js lib2-file1.js --js lib2-file2.js").and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should take the java executable name from the :java configuration option') do
+      compiler = compiler(:java => '/PATH/TO/JAVA')
+      add_one_compilation(compiler)
+      compiler.should_receive(:system).with{ |*args| args.first == '/PATH/TO/JAVA' }.and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should take the path to closure compiler from the :path configuration option') do
+      compiler = compiler(:path => '/CLOSURE.jar')
+      add_one_compilation(compiler)
+      compiler.should_receive(:system).with{ |*args| args[1..2] == ['-jar', '/CLOSURE.jar'] }.and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should interpret the path as relative to the application root') do
+      AssetLibrary.app_root = "#{tmp}/app_root"
+      compiler = compiler(:path => 'CLOSURE')
+      add_one_compilation(compiler)
+      compiler.should_receive(:system).with{ |*args| args[1..2] == ['-jar', "#{tmp}/app_root/CLOSURE"] }.and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should pass any configured java_flags to java') do
+      compiler = compiler(:java_flags => "-foo -bar")
+      add_one_compilation(compiler)
+      compiler.should_receive(:system).with{ |*args| args[1..2] == ['-foo', '-bar'] }.and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should accept an Array for java_flags') do
+      compiler = compiler(:java_flags => %w"-foo -bar")
+      add_one_compilation(compiler)
+      compiler.should_receive(:system).with{ |*args| args[1..2] == ['-foo', '-bar'] }.and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should pass any configured flags to the compiler') do
+      compiler = compiler(:flags => "--foo --bar")
+      add_one_compilation(compiler)
+      compiler.should_receive(:system).with{ |*args| args[3..4] == ['--foo', '--bar'] }.and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should add module compiler flags to the compiler command') do
+      compiler = self.compiler
+      compiler.add_asset_module mock_asset_module('lib1', :format, 'LIB1.js', 'lib1-file1.js', :compiler_flags => ['--foo'])
+      compiler.add_asset_module mock_asset_module('lib2', :format, 'LIB2.js', 'lib2-file1.js', :compiler_flags => ['--bar'])
+      compiler.should_receive(:system).with(*%W"java -jar /PATH/TO/CLOSURE.jar --foo --js_output_file LIB1.js --js lib1-file1.js").and_return(true)
+      compiler.should_receive(:system).with(*%W"java -jar /PATH/TO/CLOSURE.jar --bar --js_output_file LIB2.js --js lib2-file1.js").and_return(true)
+      compiler.write_all_caches(:format)
+    end
+
+    it('should raise a Compiler::Error if the compiler fails') do
+      compiler = self.compiler
+      compiler.add_asset_module mock_asset_module('lib1', :format, "lib1.js", "file1.js")
+      compiler.stub!(:system).and_return(false)
+      lambda{compiler.write_all_caches(:format)}.should raise_error(AssetLibrary::Compiler::Error)
+    end
+  end
+end

data/spec/asset_library/compiler/default_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe(AssetLibrary::Compiler::Default) do
+  include TemporaryDirectory
+  include CompilerHelpers
+
+  before do
+    @compiler = AssetLibrary::Compiler::Default.new(nil)
+  end
+
+  describe('#write_all_caches') do
+    it('should concatenate each set of input files to produce the respective output files') do
+      write_file "lib1-file1.txt", "lib1-file1\n"
+      write_file "lib2-file1.txt", "lib2-file1\n"
+      write_file "lib2-file2.txt", "lib2-file2\n"
+      @compiler.add_asset_module mock_asset_module('lib1', :format, "#{tmp}/lib1.txt", "#{tmp}/lib1-file1.txt")
+      @compiler.add_asset_module mock_asset_module('lib2', :format, "#{tmp}/lib2.txt", "#{tmp}/lib2-file1.txt", "#{tmp}/lib2-file2.txt")
+      @compiler.write_all_caches(:format)
+      File.read("#{tmp}/lib1.txt").should == "lib1-file1\n"
+      File.read("#{tmp}/lib2.txt").should == "lib2-file1\nlib2-file2\n"
+    end
+
+    def write_file(path, content)
+      open("#{tmp}/#{path}", 'w'){|f| f.print content}
+    end
+  end
+end

data/spec/asset_library/compiler_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe(AssetLibrary::Compiler) do
+  Compiler = AssetLibrary::Compiler
+  include TemporaryDirectory
+
+  before do
+    AssetLibrary.app_root = "#{tmp}/app_root"
+    AssetLibrary.root = "#{tmp}/root"
+  end
+
+  describe('.create') do
+    it('should return a Default compiler for :default') do
+      Compiler.create(:default).should be_a(Compiler::Default)
+    end
+
+    it('should return a Closure compiler for :closure') do
+      Compiler.create(:closure, :path => '').should be_a(Compiler::Closure)
+    end
+
+    it('should pass the configuration to the compiler') do
+      Compiler.create(:default, {:param => 2}).config[:param].should == 2
+    end
+  end
+
+  describe('.register') do
+    TestCompiler = Class.new(Compiler::Base)
+
+    it('should register a custom compiler type') do
+      Compiler.register(:test, TestCompiler)
+      compiler = Compiler.create(:test)
+      compiler.should be_a(TestCompiler)
+    end
+  end
+end

data/spec/asset_library/helpers_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 require File.dirname(__FILE__) + '/../../lib/asset_library/helpers'
 

data/spec/asset_library_spec.rb

@@ -1,16 +1,8 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe(AssetLibrary) do
-  before(:each) do
-    @old_root = AssetLibrary.root
-    @old_config_path = AssetLibrary.config_path
-    @old_cache = AssetLibrary.cache
-  end
-
-  after(:each) do
-    AssetLibrary.root = @old_root
-    AssetLibrary.config_path = @old_config_path
-    AssetLibrary.cache = @old_cache
+  def config_skeleton
+    {:modules => {}, :compilers => {}}
   end
 
   describe('#config') do
@@ -21,10 +13,10 @@ describe(AssetLibrary) do
       AssetLibrary.config
     end
 
-    it('should return {} if config_path does not exist') do
+    it('should return a skeletal configuration if config_path does not exist') do
       AssetLibrary.config_path = '/config.yml'
       File.stub!(:exist?).with('/config.yml').and_return(false)
-      AssetLibrary.config.should == {}
+      AssetLibrary.config.should == config_skeleton
     end
 
     it('should cache config if cache is set') do
@@ -58,13 +50,26 @@ describe(AssetLibrary) do
         { 'a' => { 'b' =>  'c' } }
       )
 
-      AssetLibrary.config.should == { :a => { :b => 'c' } }
+      AssetLibrary.config.should == config_skeleton.merge(:a => {:b => 'c'})
+    end
+
+    it('should accept a v0.4 config file with a deprecation warning') do
+      AssetLibrary.cache = false
+      AssetLibrary.config_path = '/config.yml'
+
+      File.stub!(:exist?).with('/config.yml').and_return(true)
+      YAML.should_receive(:load_file).with('/config.yml').and_return(
+        { 'a' => { 'files' => ['a.js'] } }
+      )
+      AssetLibrary.should_receive(:warn)
+
+      AssetLibrary.config.should == { :compilers => {}, :modules => { :a => { :files => ['a.js'] } } }
     end
   end
 
   describe('#asset_module') do
     before(:each) do
-      @config = {}
+      @config = config_skeleton
       AssetLibrary.stub!(:config).and_return(@config)
     end
 
@@ -73,25 +78,43 @@ describe(AssetLibrary) do
     end
 
     it('should return an AssetModule when given a valid key') do
-      @config[:foo] = {}
+      @config[:modules][:foo] = {}
       AssetLibrary.asset_module(:foo).should(be_a(AssetLibrary::AssetModule))
     end
   end
 
-  describe('#write_all_caches') do
-    it('should call write_all_caches on all asset_modules') do
-      mock1 = mock
-      mock2 = mock
+  describe('#compiler') do
+    include TemporaryDirectory
+
+    before do
+      AssetLibrary.app_root = "#{tmp}/root"
+    end
 
-      mock1.should_receive(:write_all_caches)
-      mock2.should_receive(:write_all_caches)
+    it('should return a Default compiler if no compiler type has been configured for the given asset module') do
+      configure_compilers
+      asset_module = mock(:compiler_type => :default)
+      AssetLibrary.compiler(asset_module).should be_a(AssetLibrary::Compiler::Default)
+    end
 
-      AssetLibrary.stub!(:asset_module).with(:mock1).and_return(mock1)
-      AssetLibrary.stub!(:asset_module).with(:mock2).and_return(mock2)
+    it('should return a compiler of the configured type for the given asset module, if one is given') do
+      configure_compilers
+      asset_module = mock(:compiler_type => :closure)
+      AssetLibrary.compiler(asset_module).should be_a(AssetLibrary::Compiler::Closure)
+    end
 
-      AssetLibrary.stub!(:config).and_return({ :mock1 => {}, :mock2 => {} })
+    it('should pass the right compiler configuration to the compiler') do
+      config = {:default => {:foo => 2}}
+      configure_compilers(config)
+      asset_module = mock(:compiler_type => :default)
+      AssetLibrary.compiler(asset_module).config[:foo].should == 2
+    end
 
-      AssetLibrary.write_all_caches
+    def configure_compilers(config=nil)
+      config = {:compilers => config || {:closure => {:path => 'closure.jar'}}}
+      config_path = "#{tmp}/config.yml"
+      open(config_path, 'w'){|f| YAML.dump(config, f)}
+      AssetLibrary.config_path = config_path
+      AssetLibrary.config
     end
   end
 end

data/spec/integration_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe(AssetLibrary) do
+  include TemporaryDirectory
+
+  class ReverseCompiler < AssetLibrary::Compiler::Base
+    def write_all_caches(format = nil)
+      asset_modules.each do |asset_module|
+        open(output_path(asset_module, format), 'w') do |file|
+          file.print config[:header]
+          input_paths(asset_module, format).reverse_each do |input|
+            file << File.read(input)
+          end
+        end
+      end
+    end
+  end
+
+  before do
+    AssetLibrary::Compiler.register(:reverse, ReverseCompiler)
+  end
+
+  describe "AssetLibrary.write_all_caches" do
+    it "should generate cached asset libraries for each asset module, with the configured compiler" do
+      write_file "#{tmp}/root/cssbase/stylesheet-1.css", "style1 { background: #000 }"
+      write_file "#{tmp}/root/cssbase/stylesheet-2.css.opt", "style2 { background: #fff }"
+      write_file "#{tmp}/root/jsbase/javascript-1.js", "function f1(){alert('1');}"
+      write_file "#{tmp}/root/jsbase/javascript-2.js.opt", "function f2(){alert('2');}"
+      config_path = "#{tmp}/config.yml"
+      open(config_path, 'w'){|f| f.puts <<-EOS}
+        compilers:
+          reverse:
+            header: HEADER
+
+        modules:
+          stylsheets:
+            cache: lib
+            optional_suffix: opt
+            base: cssbase
+            suffix: css
+            files:
+              - stylesheet-1
+              - stylesheet-2
+  
+          javascripts:
+            cache: lib
+            optional_suffix: opt
+            base: jsbase
+            suffix: js
+            compiler: reverse
+            files:
+              - javascript-1
+              - javascript-2
+      EOS
+      AssetLibrary.root = "#{tmp}/root"
+      AssetLibrary.config_path = config_path
+      AssetLibrary.write_all_caches
+      File.read("#{tmp}/root/cssbase/lib.css").should == "style1 { background: #000 }style2 { background: #fff }"
+      File.read("#{tmp}/root/jsbase/lib.js").should == "HEADERfunction f2(){alert('2');}function f1(){alert('1');}"
+    end
+  end
+
+  describe "AssetLibrary.delete_all_caches" do
+    it "should delete all caches" do
+      write_file "#{tmp}/root/cssbase/lib.css"
+      config_path = "#{tmp}/config.yml"
+      open(config_path, 'w'){|f| f.puts <<-EOS}
+        modules:
+          stylesheets:
+            cache: lib
+            base: cssbase
+            suffix: css
+            files:
+              - stylesheet-1
+              - stylesheet-2
+      EOS
+      AssetLibrary.root = "#{tmp}/root"
+      AssetLibrary.config_path = config_path
+      AssetLibrary.delete_all_caches
+      File.should_not exist("#{tmp}/root/cssbase/lib.css")
+    end
+  end
+
+  def write_file(path, content='...')
+    FileUtils.mkdir_p File.dirname(path)
+    open(path, 'w'){|f| f.print content}
+  end
+end

data/spec/spec_helper.rb

@@ -2,3 +2,72 @@ require 'rubygems'
 require 'spec'
 
 require File.dirname(__FILE__) + '/../lib/asset_library'
+
+module TemporaryDirectory
+  TMP = File.expand_path(File.dirname(__FILE__) + '/tmp')
+
+  def self.included(base)
+    base.before do
+      remove_tmp
+      make_tmp
+      enter_tmp
+    end
+
+    base.after do
+      leave_tmp
+      remove_tmp
+    end
+  end
+
+  def make_tmp
+    FileUtils.mkdir_p tmp
+  end
+
+  def remove_tmp
+    FileUtils.rm_rf tmp
+  end
+
+  def enter_tmp
+    @original_pwd = Dir.pwd
+    Dir.chdir tmp
+  end
+
+  def leave_tmp
+    Dir.chdir @original_pwd
+  end
+
+  def tmp
+    TMP
+  end
+end
+
+module CompilerHelpers
+  def mock_asset_module(name, format, output_path, *input_paths)
+    config = input_paths.last.is_a?(Hash) ? input_paths.pop : {}
+    output_asset = mock(:absolute_path => output_path)
+    input_assets = input_paths.map{|path| mock(:absolute_path => path)}
+    asset_module = mock(:name => name)
+    asset_module.stub!(:cache_asset).with(format).and_return(output_asset)
+    asset_module.stub!(:assets).with(format).and_return(input_assets)
+    asset_module.stub!(:compiler_flags).and_return(config[:compiler_flags] || [])
+    asset_module.stub!(:config).and_return(config)
+    asset_module
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.before do
+    @old_app_root = AssetLibrary.app_root
+    @old_root = AssetLibrary.root
+    @old_config_path = AssetLibrary.config_path
+    @old_cache = AssetLibrary.cache
+  end
+
+  config.after do
+    AssetLibrary.app_root = @app_root
+    AssetLibrary.root = @old_root
+    AssetLibrary.config_path = @old_config_path
+    AssetLibrary.cache = @old_cache
+    AssetLibrary.reset!
+  end
+end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: asset_library
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - adamh
 - alegscogs
+- oggy
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-02-09 00:00:00 -05:00
+date: 2010-02-24 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,6 +36,10 @@ files:
 - lib/asset_library.rb
 - lib/asset_library/asset.rb
 - lib/asset_library/asset_module.rb
+- lib/asset_library/compiler.rb
+- lib/asset_library/compiler/base.rb
+- lib/asset_library/compiler/closure.rb
+- lib/asset_library/compiler/default.rb
 - lib/asset_library/helpers.rb
 - lib/asset_library/rake_tasks.rb
 - lib/asset_library/util.rb
@@ -71,6 +76,11 @@ summary: Manage and bundle CSS and JavaScript files
 test_files: 
 - spec/asset_library_spec.rb
 - spec/asset_library/asset_module_spec.rb
+- spec/asset_library/compiler/default_spec.rb
+- spec/asset_library/compiler/base_spec.rb
+- spec/asset_library/compiler/closure_spec.rb
+- spec/asset_library/compiler_spec.rb
 - spec/asset_library/asset_spec.rb
 - spec/asset_library/helpers_spec.rb
 - spec/spec_helper.rb
+- spec/integration_spec.rb