adamh-asset_library 0.1.1

data/README.rdoc

@@ -0,0 +1,163 @@
+= asset_library
+
+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 adamh-asset_library --source http://gems.github.com
+
+Next, add the gem into your Rails project's config/environment.rb:
+
+  config.gem 'adamh-asset_library', :lib => 'asset_library', :source => 'http://gems.github.com'
+
+Finally, include the Rake tasks in your project:
+
+  echo "require 'asset_library/rake_tasks'" > lib/tasks/asset_library.rake
+
+== Usage
+
+Two methods are made available for your views:
+
+  <% # outputs library.js (production) or its files (development) %>
+  <%= asset_library_javascript_tags(:library) %>
+
+  <% # outputs library.css (production) or its files (development) %>
+  <%= asset_library_stylesheet_tags(:library) %>
+
+  <% # outputs library.ie6.css (production) or its files (development) %>
+  <!--[if lte IE 6]>
+    <%= asset_library_stylesheet_tags(:library, '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:
+
+  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
+    extra_suffixes: [ie6, ie7, 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")
+  #  extra_suffixes: ["other_bundle_suffix_1", "other_bundle_suffix_2"]
+  #  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>extra_suffixes</tt> allows construction of parallel modules. If you specify
+<tt>extra_suffixes</tt> as ['ie6', 'ie7'], <tt>files</tt> as <tt>file1</tt> and
+<tt>file2</tt>, <tt>module_name</tt> as <tt>module</tt>, and <tt>suffix</tt> as
+<tt>css</tt>, then three modules will be created (ignoring nonexistent files):
+
+* <tt>module.css</tt>, the concatenation of <tt>file1.css</tt> and <tt>file2.css</tt>
+* <tt>module.ie6.css</tt>, the concatenation of <tt>file1.ie6.css</tt> and <tt>file2.ie6.css</tt>
+* <tt>module.ie7.css</tt>, the concatenation of <tt>file1.ie7.css</tt> and <tt>file2.ie7.css</tt>
+
+<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>extra_suffixes</tt> as appropriate; and files without
+<tt>optional_suffix</tt> will not be output alongside files with the same name
+but lacking 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,58 @@
+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 = cache
+    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,33 @@
+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)
+    end
+
+    def relative_url
+      "#{relative_path}?#{timestamp.to_i.to_s}"
+    end
+  end
+end

data/lib/asset_library/asset_module.rb

@@ -0,0 +1,105 @@
+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(extra_suffix = nil)
+      return nil unless config
+
+      ret = []
+      config[:files].each do |requested_file|
+        ret.concat(assets_for_pattern(requested_file, extra_suffix))
+      end
+      ret.uniq!
+      ret
+    end
+
+    def contents(extra_suffix = nil)
+      s = StringIO.new
+
+      assets(extra_suffix).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(extra_suffix = nil)
+      extra = extra_suffix ? ".#{extra_suffix}" : ''
+      Asset.new(File.join(AssetLibrary.root, config[:base], "#{config[:cache]}#{extra}.#{config[:suffix]}"))
+    end
+
+    def write_cache(extra_suffix = nil)
+      File.open(cache_asset(extra_suffix).absolute_path, 'w') do |outfile|
+        outfile.write(contents(extra_suffix).read)
+      end
+    end
+
+    def write_all_caches
+      cache_suffixes = [ nil ] + (config[:extra_suffixes] || [])
+      cache_suffixes.each do |extra_suffix|
+        write_cache(extra_suffix)
+      end
+    end
+
+    private
+
+    def assets_for_pattern(pattern, extra_suffix)
+      ret = []
+
+      suffix = config[:suffix]
+      suffix = "#{extra_suffix}.#{suffix}" if extra_suffix
+
+      requested_path = File.join(AssetLibrary.root, config[:base], "#{pattern}.#{suffix}")
+
+      Dir.glob(requested_path).sort.each do |found_file|
+        found_file = maybe_add_optional_suffix_to_path(found_file)
+        next if path_contains_extra_dot?(found_file, pattern, extra_suffix)
+        ret << AssetLibrary::Asset.new(found_file)
+      end
+
+      ret
+    end
+
+    def maybe_add_optional_suffix_to_path(path)
+      if config[:optional_suffix]
+        basename = path[0..-(config[:suffix].length + 2)]
+        path_with_suffix = "#{basename}.#{config[:optional_suffix]}.#{config[:suffix]}"
+        File.exist?(path_with_suffix) ? path_with_suffix : path
+      else
+        path
+      end
+    end
+
+    def path_contains_extra_dot?(path, requested_file, extra_suffix)
+      allowed_suffixes = []
+
+      allowed_suffixes << "\\.#{Regexp.quote(extra_suffix)}" if extra_suffix
+      allowed_suffixes << "(\\.#{Regexp.quote(config[:optional_suffix])})?" if config[:optional_suffix]
+      allowed_suffixes << "\\.#{Regexp.quote(config[:suffix])}" if config[:suffix]
+
+      basename = File.basename(path)
+      requested_basename = File.basename(requested_file)
+
+      n_dots = requested_basename.count('.')
+      basename_regex = (['[^\.]+'] * (n_dots + 1)).join('\.')
+
+      regex =  /^#{basename_regex}#{allowed_suffixes.join}$/
+
+      !(basename =~ regex)
+    end
+  end
+end

data/lib/asset_library/helpers.rb

@@ -0,0 +1,40 @@
+class AssetLibrary
+  module Helpers
+    def asset_library_javascript_tags(module_key)
+      m = AssetLibrary.asset_module(module_key)
+      if AssetLibrary.cache
+        script_tag(m.cache_asset.relative_url)
+      else
+        m.assets.collect{|a| script_tag(a.relative_url)}.join("\n")
+      end
+    end
+
+    def asset_library_stylesheet_tags(module_key, extra_suffix = nil)
+      m = AssetLibrary.asset_module(module_key)
+      if AssetLibrary.cache
+        style_tag(m.cache_asset(extra_suffix).relative_url)
+      else
+        import_styles_tag(m.assets(extra_suffix).collect{|a| a.relative_url})
+      end
+    end
+
+    private
+
+    def script_tag(url)
+      "<script type=\"text/javascript\" src=\"#{url}\"></script>"
+    end
+
+    def style_tag(url)
+      "<link rel=\"stylesheet\" type=\"text/css\" href=\"#{url}\" />"
+    end
+
+    def import_styles_tag(urls)
+      urls.each_slice(30).collect{ |subset| import_style_tag(subset) }.join("\n")
+    end
+
+    def import_style_tag(urls)
+      imports = urls.collect{ |u| "@import \"#{u}\";" }
+      "<style type=\"text/css\">\n#{imports.join("\n")}\n</style>"
+    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,193 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'set'
+require 'rglob'
+
+describe(AssetLibrary::AssetModule) do
+  before(:each) do
+    AssetLibrary.stub!(:root).and_return('/')
+  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 == files
+    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 == files
+    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 == [ files.first ]
+    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 == files[0..1]
+    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 == files[1..2]
+    end
+
+    it('should use :optional_suffix when appropriate') do
+      files = [ '/c/file1.css', '/c/file1.o.css' ]
+      stub_fs(files)
+      m(css_config(:optional_suffix => 'o', :files => ['file1'])).assets.collect{|a| a.absolute_path}.should == files[1..1]
+    end
+
+    it('should not show :optional_suffix file if original is absent') do
+      files = [ '/c/file1.o.css' ]
+      stub_fs(files)
+      m(css_config(:optional_suffix => 'o', :files => ['file1'])).assets.collect{|a| a.absolute_path}.should == []
+    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 == [ '/c/file1.css' ]
+    end
+
+    it('should pick files with :extra_suffix') do
+      stub_fs([ '/c/file1.e.css' ])
+      m(css_config(:files => ['file1'])).assets('e').collect{|a| a.absolute_path}.should == [ '/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('e').collect{|a| a.absolute_path}.should == []
+    end
+
+    it('should combine :extra_suffix with :optional_suffix') do
+      stub_fs([ '/c/file1.e.css', '/c/file1.e.o.css' ])
+      m(css_config(:files => ['file1'], :optional_suffix => 'o')).assets('e').collect{|a| a.absolute_path}.should == [ '/c/file1.e.o.css' ]
+    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('e').collect{|a| a.absolute_path}.should == [ '/c/file1.e.css' ]
+    end
+
+    it('should pick files with :optional_suffix when globbing') do
+      stub_fs([ '/c/file.css', '/c/file.o.css' ])
+      m(css_config(:optional_suffix => 'o', :files => ['file*'])).assets.collect{|a| a.absolute_path}.should == [ '/c/file.o.css' ]
+    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.o.css' ])
+      m(css_config(:optional_suffix => 'o', :files => ['file*'])).assets('e').collect{|a| a.absolute_path}.should == [ '/c/file.e.o.css' ]
+    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/c/file2.css'
+    end
+  end
+
+  describe('#cache_asset') do
+    it('should use options[:cache]') do
+      m(css_config).cache_asset.absolute_path.should == '/c/cache.css'
+    end
+
+    it('should use :extra_suffix if set') do
+      m(css_config).cache_asset('e').absolute_path.should == '/c/cache.e.css'
+    end
+  end
+
+  describe('#write_cache') do
+    it('should write to cache.css') do
+      File.should_receive(:open).with('/c/cache.css', 'w')
+      m(css_config).write_cache
+    end
+
+    it('should write cache contents to cache') do
+      f = StringIO.new
+      File.stub!(:open).with('/c/cache.css', 'w').and_yield(f)
+      stub_fs([ '/c/file1.css', '/c/file2.css' ])
+      m(css_config(:files => ['file*'])).write_cache
+      f.rewind
+      f.read.should == '/c/file1.css/c/file2.css'
+    end
+
+    it('should use :extra_suffix to determine CSS output file') do
+      File.should_receive(:open).with('/c/cache.e.css', 'w')
+      m(css_config).write_cache('e')
+    end
+  end
+
+  describe('#write_all_caches') do
+    it('should write cache.css (no :extra_suffix)') do
+      File.should_receive(:open).with('/c/cache.css', 'w')
+      m(css_config).write_all_caches
+    end
+
+    it('should write no-extra_suffix and all extra_suffix files') do
+      suffixes = [ 'e1', 'e2' ]
+      File.should_receive(:open).with('/c/cache.css', 'w')
+      suffixes.each do |suffix|
+        File.should_receive(:open).with("/c/cache.#{suffix}.css", 'w')
+      end
+      m(css_config(:extra_suffixes => suffixes)).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 stub_fs(filenames)
+    filenames = Set.new(filenames)
+    File.stub!(:exist?).and_return do |path|
+      filenames.include?(path)
+    end
+
+    filenames.each do |path|
+      File.stub!(:open).with(path, 'r').and_yield(StringIO.new(path))
+    end
+
+    Dir.stub!(:glob).and_return do |path|
+      glob = RGlob::Glob.new(path)
+      filenames.select { |f| glob.match(f) }
+    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,131 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require File.dirname(__FILE__) + '/../../lib/asset_library/helpers'
+
+describe(AssetLibrary::Helpers) do
+  before(:each) do
+    AssetLibrary.stub!(:root).and_return('/')
+  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
+    end
+
+    describe('when caching') do
+      before(:each) do
+        AssetLibrary.stub!(:cache).and_return(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
+    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 append extra_suffix to the 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
+    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 append extra_suffix to 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
+    end
+  end
+
+  private
+
+  def a(path)
+    File.stub!(:mtime).and_return(Time.at(123))
+    AssetLibrary::Asset.new(path)
+  end
+
+  def h
+    c = Class.new do
+      include AssetLibrary::Helpers
+    end
+    o = 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,4 @@
+require 'rubygems'
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/asset_library'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: adamh-asset_library
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- adamh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: adam@adamhooper.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- 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
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/adamh/asset_library
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Manage and bundle CSS and JavaScript files
+test_files: 
+- spec/asset_library_spec.rb
+- spec/asset_library/asset_spec.rb
+- spec/asset_library/helpers_spec.rb
+- spec/asset_library/asset_module_spec.rb
+- spec/spec_helper.rb