alegscogs-asset_library 0.3.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alex Cox
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,177 @@
+= alegscogs-asset_library
+
+*****
+This is a fork of AdamH's asset_library gem, hosted at github.com/adamh.  
+*****
+
+
+Bundles your JavaScript and CSS, so your development environment is simple to
+code and your production environment is as fast as possible.
+
+== Installation
+
+First, install the gem:
+
+  sudo gem install alegscogs-asset_library --source http://gems.github.com
+
+Next, add the gem into your Rails project's config/environment.rb:
+
+  config.gem 'alegscogs-asset_library', :lib => 'asset_library', :source => 'http://gems.github.com'
+
+Finally, include the Rake tasks in your project:
+
+  echo "begin; require 'asset_library/rake_tasks'; rescue LoadError; end" > lib/tasks/asset_library.rake
+
+== Usage
+
+In your Rails project, edit <tt>config/asset_library.yml</tt> as described
+in the following section.
+
+Once configured, asset_library provides two helper methods for your views:
+
+  <%# outputs library.js (production) or its files (development) %>
+  <%= asset_library_javascript_tags(:javascripts) %>
+
+  <%# outputs library.css (production) or its files (development) %>
+  <%= asset_library_stylesheet_tags(:stylesheets) %>
+
+  <%# outputs library.ie6.css (production) or its files (development) %>
+  <!--[if lte IE 6]>
+    <%= asset_library_stylesheet_tags(:stylesheets, :ie6) %>
+  <![endif]-->
+
+Both helpers behave differently depending on whether
+<tt>ActionController::Base.perform_caching</tt> is true (that is, whether you
+are in <tt>development</tt> environment or not). When caching is disabled, each
+file in the module will be included. (Internet Explorer only allows 30
+<tt>style</tt> and <tt>link</tt> stylesheet tags; in development mode,
+<tt>import</tt> rules are used to work around the bug.) When caching is
+enabled, a single tag is output.
+
+When caching is enabled, the modules to include must be generated using:
+
+  rake asset_library:write
+
+These moduels can be removed using:
+
+  rake asset_library:clean
+
+A cached module is simply the concatenation of its constituent files.
+
+== Configuration
+
+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/**/*
+
+  # 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
+  #    - ...
+
+Here are what the various configuration elements mean:
+
+<tt>module_name</tt> is the name of the module. It is passed as the first
+parameter to <tt>asset_library_javascript_tags</tt> or
+<tt>asset_library_stylesheet_tags</tt>.
+
+<tt>cache</tt> is a filename, without suffix, relative to <tt>base</tt>, where
+the module will be bundled when caching is enabled. (Ensure that <tt>files</tt>
+does not include <tt>cache_file</tt>, even with globbing.)
+
+<tt>base</tt> is the base path of the assets in URLs. For instance, in Rails,
+where stylesheets are usually served under <tt>/stylesheets</tt>, <tt>base</tt>
+should be <tt>stylesheets</tt>.
+
+<tt>suffix</tt> is either "js" or "css", depending on whether you are including
+JavaScript or CSS files.
+
+<tt>formats</tt> allows construction of parallel modules. By default, for a
+module named <tt>styles</tt> will use <tt>*.css</tt> (where <tt>*</tt> is
+specified by the <tt>files</tt> option) to generate <tt>styles.css</tt>; but
+filenames of the format <tt>*.suffix.css</tt> will be ignored in that search.
+If a <tt>format</tt> called <tt>format1</tt> is specified as
+<tt>[suffix1, suffix2]</tt>, then <tt>*.suffix1.css</tt> and
+<tt>*.suffix2.css</tt> will be included, but not <tt>*.css</tt>. (To specify
+<tt>*.css</tt>, put <tt>null</tt> in the format list.)
+
+<tt>optional_suffix</tt> will cause asset_library to check for the existence of
+files with <tt>optional_suffix</tt> suffixes, falling back to files without
+<tt>optional_suffix</tt> if necessary. For instance, if you run all your
+JavaScript files through
+{YUI Compressor}[http://developer.yahoo.com/yui/compressor/] and output the
+compressed version of <tt>file1.js</tt> as <tt>file1.compressed.js</tt>, then
+set <tt>optional_suffix</tt> to <tt>compressed</tt>. In your development
+environment, where <tt>compressed</tt> javascripts are missing,
+<tt>file1.js</tt> will be included and you can debug your JavaScript. In your
+production environment, create the <tt>compressed</tt> JavaScripts in the same
+directory, and they will be included instead, for optimal download speed.
+
+<tt>files</tt> is a list of files, relative to <tt>base</tt>. File globbing is
+allowed; <tt>**</tt> expands to "any nesting of directories". Files which do
+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.
+
+== Copyright
+
+I believe in software freedom, not any abomination thereof. This project is
+released under the Public Domain, meaning I relinquish my copyright (to any
+extend the law allows) and grant you all rights to use, modify, sell, or
+otherwise take advantage of my software.
+
+However, I do kindly request that, as a favor, you refrain from using my
+software as part of an evil plan involving velociraptors and mind-controlling
+robots (even though I would not be legally entitled to sue you for doing so). 

data/lib/asset_library.rb

@@ -0,0 +1,71 @@
+begin
+  require 'glob_fu'
+rescue LoadError
+  require 'rubygems'
+  require 'glob_fu'
+end
+
+require File.dirname(__FILE__) + '/asset_library/asset_module'
+require File.dirname(__FILE__) + '/asset_library/util'
+
+class AssetLibrary
+  class << self
+    def config_path
+      @config_path
+    end
+
+    def config_path=(config_path)
+      @config_path = config_path
+    end
+
+    def root
+      @root
+    end
+
+    def root=(root)
+      @root = root
+    end
+
+    def cache
+      return true if @cache.nil?
+      @cache
+    end
+
+    def cache=(cache)
+      @config = nil
+      @cache_vars = nil
+      @cache = cache
+    end
+
+    def cache_vars
+      # We store cache_vars even if not caching--this is our "globals"
+      @cache_vars ||= {}
+    end
+
+    def config
+      return @config if cache && @config
+      ret = if File.exist?(config_path)
+        yaml = YAML.load_file(config_path) || {}
+        Util::symbolize_hash_keys(yaml)
+      else
+        {}
+      end
+      @config = cache ? ret : nil
+      ret
+    end
+
+    def asset_module(key)
+      module_config = config[key.to_sym]
+      if module_config
+        AssetModule.new(module_config)
+      end
+    end
+
+    def write_all_caches
+      config.keys.each do |key|
+        m = asset_module(key)
+        m.write_all_caches
+      end
+    end
+  end
+end

data/lib/asset_library/asset.rb

@@ -0,0 +1,35 @@
+class AssetLibrary
+  class Asset
+    attr_reader(:absolute_path)
+
+    def initialize(absolute_path)
+      @absolute_path = absolute_path
+    end
+
+    def eql?(other)
+      self.class === other && absolute_path == other.absolute_path
+    end
+
+    def hash
+      self.absolute_path.hash
+    end
+
+    def relative_path
+      if AssetLibrary.root == '/'
+        absolute_path
+      else
+        absolute_path[AssetLibrary.root.length..-1]
+      end
+    end
+
+    def timestamp
+      File.mtime(absolute_path)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def relative_url
+      "#{relative_path}?#{timestamp.to_i.to_s}"
+    end
+  end
+end

data/lib/asset_library/asset_module.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/asset'
+
+class AssetLibrary
+  class AssetModule
+    attr_reader(:config)
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Returns an Array of Assets to include.
+    #
+    # Arguments:
+    #   extra_suffix: if set, finds files with the given extra suffix
+    def assets(format = nil)
+      if format
+        assets_with_format(format)
+      else
+        assets_with_extra_suffix(nil)
+      end
+    end
+
+    # Returns an Array of Assets to include.
+    #
+    # Arguments:
+    #   extra_suffix: if set, finds files with the given extra suffix
+    def assets_with_extra_suffix(extra_suffix)
+      return nil unless config
+
+      GlobFu.find(
+        config[:files],
+        :suffix => config[:suffix],
+        :extra_suffix => extra_suffix,
+        :root => File.join(*([AssetLibrary.root, config[:base]].compact)),
+        :optional_suffix => config[:optional_suffix]
+      ).collect { |f| Asset.new(f) }
+    end
+
+    # Returns an Array of Assets to include.
+    #
+    # Calls assets_with_extra_suffix for each suffix in the given format
+    #
+    # Arguments:
+    #   format: format specified in the config
+    def assets_with_format(format)
+      return nil unless config
+
+      extra_suffixes = config[:formats][format.to_sym]
+      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/helpers.rb

@@ -0,0 +1,96 @@
+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,25 @@
+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')
+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
+    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
+  end
+end

data/lib/asset_library/util.rb

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

data/rails/init.rb

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

data/spec/asset_library/asset_module_spec.rb

@@ -0,0 +1,216 @@
+require 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('#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"
+    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('#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)
+  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

data/spec/asset_library/asset_spec.rb

@@ -0,0 +1,49 @@
+require 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/helpers_spec.rb

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

data/spec/asset_library_spec.rb

@@ -0,0 +1,97 @@
+require 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
+  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 {} if config_path does not exist') do
+      AssetLibrary.config_path = '/config.yml'
+      File.stub!(:exist?).with('/config.yml').and_return(false)
+      AssetLibrary.config.should == {}
+    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 == { :a => { :b => 'c' } }
+    end
+  end
+
+  describe('#asset_module') do
+    before(:each) do
+      @config = {}
+      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[: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
+
+      mock1.should_receive(:write_all_caches)
+      mock2.should_receive(:write_all_caches)
+
+      AssetLibrary.stub!(:asset_module).with(:mock1).and_return(mock1)
+      AssetLibrary.stub!(:asset_module).with(:mock2).and_return(mock2)
+
+      AssetLibrary.stub!(:config).and_return({ :mock1 => {}, :mock2 => {} })
+
+      AssetLibrary.write_all_caches
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/asset_library'
+
+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

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: alegscogs-asset_library
+version: !ruby/object:Gem::Version 
+  version: 0.3.4
+platform: ruby
+authors: 
+- Alex Cox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: adamh-glob_fu
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.4
+    version: 
+description: 
+email: alexc@patch.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- lib/asset_library.rb
+- lib/asset_library/asset.rb
+- lib/asset_library/asset_module.rb
+- lib/asset_library/helpers.rb
+- lib/asset_library/rake_tasks.rb
+- lib/asset_library/util.rb
+- rails/init.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/alegscogs/alegscogs-asset_library
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Manage and bundle CSS and JavaScript files
+test_files: 
+- spec/asset_library/asset_module_spec.rb
+- spec/asset_library/asset_spec.rb
+- spec/asset_library/helpers_spec.rb
+- spec/asset_library_spec.rb
+- spec/spec_helper.rb