patch-asset_library 0.5.0.1

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/compiler/base.rb

@@ -0,0 +1,20 @@
+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
+    end
+  end
+end

data/lib/asset_library/compiler/closure.rb

@@ -0,0 +1,41 @@
+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|
+          asset_module.each_compilation do |inputs, output|
+            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}"
+            inputs.each do |input|
+              command << '--js' << input
+            end
+            system *command or
+              raise Error, "closure compiler failed"
+          end
+        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|
+          asset_module.each_compilation do |inputs, output|
+            open(output, 'w') do |file|
+              inputs.each { |path| file << File.read(path) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asset_library/helpers.rb

@@ -0,0 +1,98 @@
+require 'enumerator'
+
+class AssetLibrary
+  module Helpers
+    def asset_library_javascript_tags(module_key, format = nil)
+      
+      m = AssetLibrary.asset_module(module_key)
+      if AssetLibrary.cache
+        AssetLibrary.cache_vars[:javascript_tags] ||= {}
+        AssetLibrary.cache_vars[:javascript_tags][module_key] ||= asset_library_priv.script_tag(m.cache_asset)
+      else
+        m.assets(format).collect{|a| asset_library_priv.script_tag(a)}.join("\n")
+      end
+    end
+
+    def asset_library_stylesheet_tags(module_key, *args)
+      html_options = args.last.is_a?(Hash) ? args.pop : {}
+      format = args[0]
+      
+      m = AssetLibrary.asset_module(module_key)
+      if AssetLibrary.cache
+        AssetLibrary.cache_vars[:stylesheet_tags] ||= {}
+        AssetLibrary.cache_vars[:stylesheet_tags][[module_key, format, request.protocol, request.host_with_port]] ||= asset_library_priv.style_tag(m.cache_asset(format), html_options)
+      else
+        asset_library_priv.import_styles_tag(m.assets(format), html_options)
+      end
+    end
+
+    private
+
+    def asset_library_priv
+      @asset_library_priv ||= Priv.new(self)
+    end
+
+    class Priv
+      # Don't pollute helper's class's namespace with all our methods; put
+      # them here instead
+
+      attr_accessor :helper
+
+      def initialize(helper)
+        @helper = helper
+      end
+
+      def url(asset)
+        absolute_url(asset.relative_url)
+      end
+
+      def absolute_url(relative_url)
+        host = helper.__send__(:compute_asset_host, relative_url) if helper.respond_to?(:compute_asset_host, true)
+
+        host = nil if host == '' # Rails sets '' by default
+
+        if host && !(host =~ %r{^[-a-z]+://})
+          controller = helper.instance_variable_get(:@controller)
+          request = controller && controller.respond_to?(:request) && controller.request
+          host = request && "#{request.protocol}#{host}"
+        end
+
+        if host
+          "#{host}#{relative_url}"
+        else
+          relative_url
+        end
+      end
+
+      def script_tag(asset)
+        content_tag(:script, "", {:type => "text/javascript", :src => url(asset)})
+      end
+
+      def style_tag(asset, html_options = {})
+        "<link rel=\"stylesheet\" type=\"text/css\" href=\"#{url(asset)}\" #{attributes_from_hash(html_options)}/>"
+      end
+
+      def import_styles_tag(assets, html_options = {})
+        a = []
+        assets.each_slice(30) do |subset|
+          a << import_style_tag(subset, html_options)
+        end
+        a.join("\n")
+      end
+
+      def import_style_tag(assets, html_options = {})
+        imports = assets.collect{ |a| "@import \"#{url(a)}\";" }
+        content_tag(:style, "\n#{imports.join("\n")}\n", html_options.merge(:type => "text/css"))
+      end
+      
+      def content_tag(name, content, options = {})        
+        "<#{name} #{attributes_from_hash(options)}>#{content}</#{name}>"
+      end
+      
+      def attributes_from_hash(options = {})
+        options.to_a.collect{|k, v| "#{k}=\"#{v}\""}.join(" ")
+      end
+      
+    end
+  end
+end

data/lib/asset_library/rake_tasks.rb

@@ -0,0 +1,22 @@
+def init_asset_library
+  require 'asset_library'
+
+  # TODO: Find a way to not-hard-code these paths?
+  AssetLibrary.config_path = Rails.root + 'config/asset_library.yml'
+  AssetLibrary.root = Rails.public_path
+  AssetLibrary.app_root = Rails.root
+end
+
+namespace(:asset_library) do
+  desc "Writes all asset caches specified in config/asset.yml by concatenating the constituent files."
+  task(:write) do
+    init_asset_library
+    AssetLibrary.write_all_caches
+  end
+
+  desc "Deletes all asset caches specified in config/asset.yml"
+  task(:clean) do
+    init_asset_library
+    AssetLibrary.delete_all_caches
+  end
+end

data/lib/asset_library/util.rb

@@ -0,0 +1,26 @@
+require 'shellwords'
+
+class AssetLibrary
+  module Util
+    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
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+AssetLibrary.cache = ActionController::Base.perform_caching
+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

@@ -0,0 +1,183 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'set'
+
+describe(AssetLibrary::AssetModule) do
+  before(:each) do
+    AssetLibrary.stub!(:root).and_return(prefix)
+  end
+
+  after(:each) do
+    wipe_fs
+  end
+
+  describe('#assets') do
+    it('should include file1 and file2') do
+      files = [ '/c/file1.css', '/c/file2.css' ]
+      stub_fs(files)
+      m(css_config(:files => ['file1', 'file2'])).assets.collect{|a| a.absolute_path}.should == ["#{prefix}/c/file1.css", "#{prefix}/c/file2.css"]
+    end
+
+    it('should not include file2 if that does not exist') do
+      files = [ '/c/file1.css' ]
+      stub_fs(files)
+      m(css_config(:files => ['file1', 'file2'])).assets.collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.css" ]
+    end
+
+    it('should not include other files') do
+      files = [ '/c/file1.css', '/c/file2.css' ]
+      stub_fs(files)
+      m(css_config(:files => ['file1'])).assets.collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.css" ]
+    end
+
+    it('should glob filenames') do
+      files = [ '/c/file1.css', '/c/file2.css', '/c/other_file.css' ]
+      stub_fs(files)
+      m(css_config(:files => ['file*'])).assets.collect{|a| a.absolute_path}.should == ["#{prefix}/c/file1.css", "#{prefix}/c/file2.css"]
+    end
+
+    it('should glob directories') do
+      files = [ '/c/file1.css', '/c/a/file2.css', '/c/b/a/file3.css' ]
+      stub_fs(files)
+      m(css_config(:files => ['**/file*'])).assets.collect{|a| a.absolute_path}.should == ["#{prefix}/c/a/file2.css", "#{prefix}/c/b/a/file3.css", "#{prefix}/c/file1.css"]
+    end
+
+    it('should use :optional_suffix when appropriate') do
+      files = [ '/c/file1.css', '/c/file1.css.o' ]
+      stub_fs(files)
+      m(css_config(:optional_suffix => 'o', :files => ['file1'])).assets.collect{|a| a.absolute_path}.should == ["#{prefix}/c/file1.css.o"]
+    end
+
+    it('should show :optional_suffix file even if original is absent') do
+      files = [ '/c/file1.css.o' ]
+      stub_fs(files)
+      m(css_config(:optional_suffix => 'o', :files => ['file1'])).assets.collect{|a| a.absolute_path}.should == ["#{prefix}/c/file1.css.o"]
+    end
+
+    it('should ignore :optional_suffix when suffixed file is not present') do
+      stub_fs([ '/c/file1.css' ])
+      m(css_config(:optional_suffix => 'o', :files => ['file1'])).assets.collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.css" ]
+    end
+
+    it('should pick files with :extra_suffix') do
+      stub_fs([ '/c/file1.e.css' ])
+      m(css_config(:files => ['file1'])).assets_with_extra_suffix('e').collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.e.css" ]
+    end
+
+    it('should ignore non-suffixed files when :extra_suffix is set') do
+      stub_fs([ '/c/file1.css' ])
+      m(css_config(:files => ['file1'])).assets_with_extra_suffix('e').collect{|a| a.absolute_path}.should == []
+    end
+
+    it('should use extra suffixes with format') do
+      stub_fs([ '/c/file1.e1.css', '/c/file1.e2.css' ])
+      m(css_config(:files => ['file1'], :formats => { :f1 => [ 'e1', 'e2' ] })).assets_with_format(:f1).collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.e1.css", "#{prefix}/c/file1.e2.css" ]
+    end
+
+    it('should ignore extra suffixes unspecified in format') do
+      stub_fs([ '/c/file1.e1.css', '/c/file1.e2.css' ])
+      m(css_config(:files => ['file1'], :formats => { :f1 => [ 'e1' ] })).assets_with_format(:f1).collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.e1.css" ]
+    end
+
+    it('should allow nil suffixes in format') do
+      stub_fs([ '/c/file1.css', '/c/file1.e1.css' ])
+      m(css_config(:files => ['file1'], :formats => { :f1 => [nil, 'e1'] })).assets_with_format(:f1).collect{|a| a.absolute_path}.should == ["#{prefix}/c/file1.css", "#{prefix}/c/file1.e1.css" ]
+    end
+
+    it('should combine :extra_suffix with :optional_suffix') do
+      stub_fs([ '/c/file1.e.css', '/c/file1.e.css.o' ])
+      m(css_config(:files => ['file1'], :optional_suffix => 'o')).assets_with_extra_suffix('e').collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.e.css.o" ]
+    end
+
+    it('should ignore too many dots when globbing') do
+      stub_fs([ '/c/file1.x.css' ])
+      m(css_config(:files => ['file1*'])).assets.collect{|a| a.absolute_path}.should == []
+    end
+
+    it('should pick files with :extra_suffix when globbing') do
+      stub_fs([ '/c/file1.e.css', '/c/file2.css' ])
+      m(css_config(:files => ['file*'])).assets_with_extra_suffix('e').collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file1.e.css" ]
+    end
+
+    it('should pick files with :optional_suffix when globbing') do
+      stub_fs([ '/c/file.css', '/c/file.css.o' ])
+      m(css_config(:optional_suffix => 'o', :files => ['file*'])).assets.collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file.css.o" ]
+    end
+
+    it('should pick files with both :extra_suffix and :optional_suffix when globbing') do
+      stub_fs([ '/c/file.css', '/c/file.e.css', '/c/file.e.css.o' ])
+      m(css_config(:optional_suffix => 'o', :files => ['file*'])).assets_with_extra_suffix('e').collect{|a| a.absolute_path}.should == [ "#{prefix}/c/file.e.css.o" ]
+    end
+  end
+
+  describe('#cache_asset') do
+    it('should use options[:cache]') do
+      m(css_config).cache_asset.absolute_path.should == "#{prefix}/c/cache.css"
+    end
+
+    it('should use :format if set') do
+      m(css_config).cache_asset(:e).absolute_path.should == "#{prefix}/c/cache.e.css"
+    end
+  end
+
+  describe('#each_compilation') do
+    it('should yield each set of input and output files') do
+      stub_fs([ '/c/file1.css', '/c/file1.e1.css', '/c/file2.css' ])
+      asset_module = m(css_config( :files => ['file1', 'file2'], :formats => { :f1 => [nil, 'e1'], :f2 => ['e1'] } ))
+      yields = asset_module.to_enum(:each_compilation).to_a
+      yields.should == [
+        [["#{prefix}/c/file1.css", "#{prefix}/c/file2.css"], "#{prefix}/c/cache.css"],
+        [["#{prefix}/c/file1.css", "#{prefix}/c/file2.css", "#{prefix}/c/file1.e1.css"], "#{prefix}/c/cache.f1.css"],
+        [["#{prefix}/c/file1.e1.css"], "#{prefix}/c/cache.f2.css"],
+      ]
+    end
+  end
+
+  private
+
+  def m(config)
+    AssetLibrary::AssetModule.new(:name, config)
+  end
+
+  def js_config(options = {})
+    {
+      :cache => 'cache',
+      :base => 'j',
+      :suffix => 'js',
+      :files => [ 'file1', 'file2' ]
+    }.merge(options)
+  end
+
+  def css_config(options = {})
+    {
+      :cache => 'cache',
+      :base => 'c',
+      :suffix => 'css',
+      :files => [ 'file1', 'file2' ]
+    }.merge(options)
+  end
+
+  def prefix
+    @prefix ||= File.dirname(__FILE__) + '/deleteme'
+  end
+
+  def stub_fs(filenames)
+    wipe_fs
+    FileUtils.mkdir(prefix)
+
+    filenames.each do |file|
+      path = File.join(prefix, file)
+      dir = File.dirname(path)
+      unless File.exist?(dir)
+        FileUtils.mkdir_p(dir)
+      end
+      File.open(path, 'w') { |f| f.write("#{file}\n") }
+    end
+  end
+
+  def wipe_fs
+    if File.exist?(prefix)
+      FileUtils.rm_r(prefix)
+    end
+  end
+end