patch-asset_library 0.5.0.1

data/spec/asset_library/asset_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require File.dirname(__FILE__) + '/../../lib/asset_library/asset'
+
+describe(AssetLibrary::Asset) do
+  it('should have eql? work for identical assets') do
+    a('/a/b.css').should eql(a('/a/b.css'))
+  end
+
+  it('should use absolute_path as its hash') do
+    a('/a/b.css').hash.should == '/a/b.css'.hash
+  end
+
+  context('#relative_path') do
+    it('should strip AssetLibrary.root') do
+      AssetLibrary.stub!(:root).and_return('/r')
+      a('/r/a/b.css').relative_path.should == '/a/b.css'
+    end
+
+    it('should strip nothing if root is "/"') do
+      AssetLibrary.stub!(:root).and_return('/')
+      a('/r/a/b.css').relative_path.should == '/r/a/b.css'
+    end
+  end
+
+  context('#timestamp') do
+    it('should return the file mtime') do
+      File.stub!(:mtime).with('/r/a/b.css').and_return(Time.at(123))
+      a('/r/a/b.css').timestamp.should == Time.at(123)
+    end
+  end
+
+  context('#relative_url') do
+    before(:each) do
+      AssetLibrary.stub!(:root).and_return('/r')
+    end
+
+    it('should use relative path and mtime') do
+      File.stub!(:mtime).with('/r/a/b.css').and_return(Time.at(123))
+      a('/r/a/b.css').relative_url.should == '/a/b.css?123'
+    end
+  end
+
+  private
+
+  def a(*args)
+    AssetLibrary::Asset.new(*args)
+  end
+end

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

@@ -0,0 +1,210 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require File.dirname(__FILE__) + '/../../lib/asset_library/helpers'
+
+describe(AssetLibrary::Helpers) do
+  before(:each) do
+    @h = nil
+    AssetLibrary.stub!(:root).and_return('/')
+  end
+  before(:each) do
+    @old_cache = AssetLibrary.cache # Empty globals
+  end
+
+  after(:each) do
+    @h = nil
+  end
+  after(:each) do
+    AssetLibrary.cache = @old_cache
+    @old_cache = nil
+  end
+
+  describe('#asset_library_javascript_tags') do
+    describe('when not caching') do
+      before(:each) do
+        AssetLibrary.stub!(:cache).and_return(false)
+      end
+
+      it('should fetch using asset_module') do
+        m = mock(:assets => [])
+        AssetLibrary.should_receive(:asset_module).with(:m).and_return(m)
+        h.asset_library_javascript_tags(:m)
+      end
+
+      it('should output nothing when a module is empty') do
+        m = mock(:assets => [])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_javascript_tags(:m).should == ''
+      end
+
+      it('should output a <script> tag for a file') do
+        m = mock(:assets => [a('/f.js')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_javascript_tags(:m).should == '<script type="text/javascript" src="/f.js?123"></script>'
+      end
+
+      it('should join <script> tags with newlines') do
+        m = mock(:assets => [a('/f.js'), a('/f2.js')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_javascript_tags(:m).should == '<script type="text/javascript" src="/f.js?123"></script>' + "\n" + '<script type="text/javascript" src="/f2.js?123"></script>'
+      end
+
+      it('should use compute_asset_host if available') do
+        m = mock(:assets => [a('/f.js')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.should_receive(:compute_asset_host).with('/f.js?123').and_return('http://assets.test')
+        h.asset_library_javascript_tags(:m).should =~ %r{"http://assets.test/f.js\?123"}
+      end
+
+      it('should not use compute_asset_host if it returns nil') do
+        m = mock(:assets => [a('/f.js')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.should_receive(:compute_asset_host).and_return(nil)
+        h.asset_library_javascript_tags(:m).should =~ %r{"/f.js\?123"}
+      end
+
+      it('should not use compute_asset_host if it returns ""') do
+        m = mock(:assets => [a('/f.js')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.should_receive(:compute_asset_host).and_return("")
+        h.asset_library_javascript_tags(:m).should =~ %r{"/f.js\?123"}
+      end
+
+      it('should add request protocol to compute_asset_host output if applicable') do
+        m = mock(:assets => [a('/f.js')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.stub!(:compute_asset_host).and_return('assets.test')
+        h.instance_variable_set(:@controller, mock(:request => mock(:protocol => 'http://')))
+        h.asset_library_javascript_tags(:m).should =~ %r{"http://assets.test/f.js\?123"}
+      end
+    end
+
+    describe('when caching') do
+      before(:each) do
+        AssetLibrary.cache = true
+      end
+
+      it('should output a single <script> tag with the cache filename') do
+        m = mock(:cache_asset => a('/cache.js'))
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_javascript_tags(:m).should == '<script type="text/javascript" src="/cache.js?123"></script>'
+      end
+
+      it('should use compute_asset_host if available') do
+        m = mock(:cache_asset => a('/cache.js'))
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.should_receive(:compute_asset_host).with('/cache.js?123').and_return('http://assets.test')
+        h.asset_library_javascript_tags(:m)
+        h.asset_library_javascript_tags(:m).should =~ %r{"http://assets.test/cache.js\?123"}
+      end
+    end
+  end
+
+  describe('#asset_library_stylesheet_tags') do
+    describe('when not caching') do
+      before(:each) do
+        AssetLibrary.stub!(:cache).and_return(false)
+      end
+
+      it('should fetch using asset_module') do
+        m = mock(:assets => [])
+        AssetLibrary.should_receive(:asset_module).with(:m).and_return(m)
+        h.asset_library_stylesheet_tags(:m)
+      end
+
+      it('should output nothing when a module is empty') do
+        m = mock(:assets => [])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m).should == ''
+      end
+
+      it('should output a single <script> with a single @import when there is one file') do
+        m = mock(:assets => [a('/f.css')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m).should == "<style type=\"text/css\">\n@import \"\/f.css?123\";\n</style>"
+      end
+
+      it('should use formats to find cache filename') do
+        m = mock
+        m.should_receive(:assets).with(:e).and_return([a('f.e.css')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m, :e).should == "<style type=\"text/css\">\n@import \"f.e.css?123\";\n</style>"
+      end
+
+      it('should output a single <script> tag with 30 @import') do
+        m = mock(:assets => (1..30).collect{|i| a("/f#{i}.css") })
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m).should =~ /\<style type=\"text\/css\"\>(\n@import \"\/f\d+.css\?123\";){30}\n\<\/style\>/
+      end
+
+      it('should output two <script> tags with 31 @imports') do
+        m = mock(:assets => (1..31).collect{|i| a("/f#{i}.css") })
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m).should =~ /\<style type="text\/css"\>(\n@import "\/f\d+.css\?123";){30}\n\<\/style\>\n<style type="text\/css"\>\n@import "\/f31.css\?123";\n\<\/style\>/
+      end
+      
+      it('should output a final hash in the parameters as html attributes') do
+        m = mock(:assets => [a('/f.css')])
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        optional_hash = {:key1 => "val1", :key2 => "val2", :key3 => "val3"}
+        attributes_to_hash( h.asset_library_stylesheet_tags(:m, optional_hash), [:type] ).should == optional_hash
+      end
+    end
+
+    describe('when caching') do
+      before(:each) do
+        AssetLibrary.stub!(:cache).and_return(true)
+      end
+
+      it('should output a single <style> tag with the cache filename') do
+        m = mock(:cache_asset => a('/cache.css'))
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m).should == '<link rel="stylesheet" type="text/css" href="/cache.css?123" />'
+      end
+
+      it('should use format for the cache filename') do
+        m = mock
+        m.should_receive(:cache_asset).with(:e).and_return(a('/cache.e.css'))
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        h.asset_library_stylesheet_tags(:m, :e).should == '<link rel="stylesheet" type="text/css" href="/cache.e.css?123" />'
+      end
+
+      it('should output a final hash in the parameters as html attributes') do
+        m = mock(:cache_asset => a('/cache.css'))
+        AssetLibrary.stub!(:asset_module).and_return(m)
+        optional_hash = {:key1 => "val1", :key2 => "val2", :key3 => "val3"}
+        attributes_to_hash(h.asset_library_stylesheet_tags(:m, optional_hash), [:type, :rel, :href]).should == optional_hash
+      end
+    end
+  end
+
+  private
+
+  def a(path)
+    File.stub!(:mtime).and_return(Time.at(123))
+    AssetLibrary::Asset.new(path)
+  end
+
+  def h
+    return @h if @h
+    c = Class.new do
+      include AssetLibrary::Helpers
+    end
+    @h = c.new
+    @h.stub!(:request).and_return(mock(:protocol => 'http://', :host_with_port => 'example.com'))
+    @h
+  end
+
+  def attributes_to_hash(string, without = [])
+    hash_from_tag_attributes = {}
+    
+    string.scan(/\s([^\s=]+="[^"]*)"/).each do |attr| 
+      a = attr[0].split("=\"")
+      hash_from_tag_attributes.merge!( a[0].to_sym => a[1] ) 
+    end
+    
+    without.each{|k| hash_from_tag_attributes.delete k} 
+    
+    hash_from_tag_attributes
+  end
+end

data/spec/asset_library_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe(AssetLibrary) do
+  def config_skeleton
+    {:modules => {}, :compilers => {}}
+  end
+
+  describe('#config') do
+    it('should YAML.load_file the config from config_path') do
+      AssetLibrary.config_path = '/config.yml'
+      File.stub!(:exist?).with('/config.yml').and_return(true)
+      YAML.should_receive(:load_file).with('/config.yml')
+      AssetLibrary.config
+    end
+
+    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 == config_skeleton
+    end
+
+    it('should cache config if cache is set') do
+      AssetLibrary.cache = true
+      AssetLibrary.config_path = '/config.yml'
+
+      File.stub!(:exist?).with('/config.yml').and_return(true)
+      YAML.should_receive(:load_file).with('/config.yml').once
+
+      AssetLibrary.config
+      AssetLibrary.config
+    end
+
+    it('should not cache config if cache is not set') 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').twice
+
+      AssetLibrary.config
+      AssetLibrary.config
+    end
+
+    it('should symbolize config hash keys') 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' => { '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_skeleton
+      AssetLibrary.stub!(:config).and_return(@config)
+    end
+
+    it('should return nil when given an invalid key') do
+      AssetLibrary.asset_module(:foo).should == nil
+    end
+
+    it('should return an AssetModule when given a valid key') do
+      @config[:modules][:foo] = {}
+      AssetLibrary.asset_module(:foo).should(be_a(AssetLibrary::AssetModule))
+    end
+  end
+
+  describe('#compiler') do
+    include TemporaryDirectory
+
+    before do
+      AssetLibrary.app_root = "#{tmp}/root"
+    end
+
+    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
+
+    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
+
+    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
+
+    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