jammit 0.4.4 → 0.5.0

data/bin/jammit

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby -rrubygems
 
 require "#{File.dirname(__FILE__)}/../lib/jammit/command_line.rb"
 

data/jammit.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name      = 'jammit'
-  s.version   = '0.4.4'         # Keep version in sync with jammit.rb
-  s.date      = '2010-2-6'
+  s.version   = '0.5.0'         # Keep version in sync with jammit.rb
+  s.date      = '2010-2-19'
 
   s.homepage    = "http://documentcloud.github.com/jammit/"
   s.summary     = "Industrial Strength Asset Packaging for Rails"
@@ -27,7 +27,6 @@ Gem::Specification.new do |s|
                          '--main'     << 'README' <<
                          '--all'
 
-  s.add_dependency 'rails',             ['>= 2.0.0']
   s.add_dependency 'yui-compressor',    ['>= 0.9.1']
   s.add_dependency 'closure-compiler',  ['>= 0.1.0']
 

data/lib/jammit/compressor.rb

@@ -23,18 +23,18 @@ module Jammit
     EMBED_EXTS      = EMBED_MIME_TYPES.keys
     EMBED_FONTS     = ['.ttf', '.otf']
 
-    # 32k maximum size for embeddable images (an IE8 limitation).
-    MAX_IMAGE_SIZE  = 32768
+    # (32k - padding) maximum length for data-uri assets (an IE8 limitation).
+    MAX_IMAGE_SIZE  = 32700
 
     # CSS asset-embedding regexes for URL rewriting.
     EMBED_DETECTOR  = /url\(['"]?([^\s)]+\.[a-z]+)(\?\d+)?['"]?\)/
     EMBEDDABLE      = /[\A\/]embed\//
-    EMBED_REPLACER  = /url\(__EMBED__([^\s)]+)(\?\d+)?\)/
+    EMBED_REPLACER  = /url\(__EMBED__(.+?)(\?\d+)?\)/
 
     # MHTML file constants.
-    MHTML_START     = "/*\r\nContent-Type: multipart/related; boundary=\"JAMMIT_MHTML_SEPARATOR\"\r\n\r\n"
-    MHTML_SEPARATOR = "--JAMMIT_MHTML_SEPARATOR\r\n"
-    MHTML_END       = "*/\r\n"
+    MHTML_START     = "/*\r\nContent-Type: multipart/related; boundary=\"MHTML_MARK\"\r\n\r\n"
+    MHTML_SEPARATOR = "--MHTML_MARK\r\n"
+    MHTML_END       = "\r\n--MHTML_MARK--\r\n*/\r\n"
 
     # JST file constants.
     JST_START       = "(function(){"
@@ -61,9 +61,13 @@ module Jammit
     end
 
     # Concatenate together a list of JavaScript paths, and pass them through the
-    # YUI Compressor (with munging enabled).
+    # YUI Compressor (with munging enabled). JST can optionally be included.
     def compress_js(paths)
-      js = concatenate(paths)
+      if (jst_paths = paths.grep(Jammit.template_extension_matcher)).empty?
+        js = concatenate(paths)
+      else
+        js = concatenate(paths - jst_paths) + compile_jst(jst_paths)
+      end
       Jammit.compress_assets ? @js_compressor.compress(js) : js
     end
 
@@ -71,6 +75,7 @@ module Jammit
     # :datauri or :mhtml variant, post-processes the result to embed
     # referenced assets.
     def compress_css(paths, variant=nil, asset_url=nil)
+      @asset_contents = {}
       css = concatenate_and_tag_assets(paths, variant)
       css = @css_compressor.compress(css) if Jammit.compress_assets
       case variant
@@ -87,11 +92,13 @@ module Jammit
     # specified your own preferred function, or turned it off.
     # JST templates are named with the basename of their file.
     def compile_jst(paths)
-      namespace = Jammit.template_namespace
-      compiled = paths.map do |path|
-        template_name = File.basename(path, File.extname(path))
-        contents      = File.read(path).gsub(/\n/, '').gsub("'", '\\\\\'')
-        "#{namespace}.#{template_name} = #{Jammit.template_function}('#{contents}');"
+      namespace   = Jammit.template_namespace
+      paths       = paths.grep(Jammit.template_extension_matcher).sort
+      base_path   = find_base_path(paths)
+      compiled    = paths.map do |path|
+        contents  = File.read(path).gsub(/\n/, '').gsub("'", '\\\\\'')
+        name      = template_name(path, base_path)
+        "#{namespace}['#{name}'] = #{Jammit.template_function}('#{contents}');"
       end
       compiler = Jammit.include_jst_script ? File.read(DEFAULT_JST_SCRIPT) : '';
       setup_namespace = "#{namespace} = #{namespace} || {};"
@@ -101,6 +108,27 @@ module Jammit
 
     private
 
+    # Given a set of paths, find a common prefix path.
+    def find_base_path(paths)
+      return nil if paths.length <= 1
+      paths.sort!
+      first = paths.first.split('/')
+      last  = paths.last.split('/')
+      i = 0
+      while first[i] == last[i] && i <= first.length
+        i += 1
+      end
+      res = first.slice(0, i).join('/')
+      res.empty? ? nil : res
+    end
+
+    # Determine the name of a JS template. If there's a common base path, use
+    # the namespaced prefix. Otherwise, simply use the filename.
+    def template_name(path, base_path)
+      return File.basename(path, ".#{Jammit.template_extension}") unless base_path
+      path.gsub(/\A#{base_path}\/(.*)\.#{Jammit.template_extension}\Z/, '\1')
+    end
+
     # In order to support embedded assets from relative paths, we need to
     # expand the paths before contatenating the CSS together and losing the
     # location of the original stylesheet path. Validate the assets while we're
@@ -168,7 +196,7 @@ module Jammit
     # append the RAILS_ASSET_ID cache-buster to URLs, if it's defined.
     def rewrite_asset_path(path, file_path)
       asset_id = rails_asset_id(file_path)
-      asset_id.blank? ? path : "#{path}?#{asset_id}"
+      (!asset_id || asset_id == '') ? path : "#{path}?#{asset_id}"
     end
 
     # Similar to the AssetTagHelper's method of the same name, this will
@@ -180,23 +208,23 @@ module Jammit
     end
 
     # An asset is valid for embedding if it exists, is less than 32K, and is
-    # stored somewhere inside of a folder named "embed".
-    # IE does not support Data-URIs larger than 32K, and you probably shouldn't
-    # be embedding assets that large in any case.
+    # stored somewhere inside of a folder named "embed". IE does not support
+    # Data-URIs larger than 32K, and you probably shouldn't be embedding assets
+    # that large in any case. Because we need to check the base64 length here,
+    # save it so that we don't have to compute it again later.
     def embeddable?(asset_path, variant)
       font = EMBED_FONTS.include?(asset_path.extname)
       return false unless variant
       return false unless asset_path.to_s.match(EMBEDDABLE) && asset_path.exist?
       return false unless EMBED_EXTS.include?(asset_path.extname)
-      return false unless font || asset_path.size < MAX_IMAGE_SIZE
+      return false unless font || encoded_contents(asset_path).length < MAX_IMAGE_SIZE
       return false if font && variant == :mhtml
-      true
+      return true
     end
 
     # Return the Base64-encoded contents of an asset on a single line.
     def encoded_contents(asset_path)
-      data = File.open(asset_path, 'rb'){|f| f.read }
-      Base64.encode64(data).gsub(/\n/, '')
+      @asset_contents[asset_path] ||= Base64.encode64(File.read(asset_path)).gsub(/\n/, '')
     end
 
     # Grab the mime-type of an asset, by filename.

data/lib/jammit/controller.rb

@@ -5,7 +5,7 @@ module Jammit
   # missing or uncached asset packages.
   class Controller < ActionController::Base
 
-    VALID_FORMATS   = [:css, :js, :jst]
+    VALID_FORMATS   = [:css, :js]
 
     SUFFIX_STRIPPER = /-(datauri|mhtml)\Z/
 
@@ -16,9 +16,12 @@ module Jammit
     def package
       parse_request
       case @extension
-      when :js  then render :js   => (@contents = Jammit.packager.pack_javascripts(@package))
-      when :css then render :text => generate_stylesheets, :content_type => 'text/css'
-      when :jst then render :js   => (@contents = Jammit.packager.pack_templates(@package))
+      when :js
+        render :js => (@contents = Jammit.packager.pack_javascripts(@package))
+      when Jammit.template_extension.to_sym
+        render :js => (@contents = Jammit.packager.pack_templates(@package))
+      when :css
+        render :text => generate_stylesheets, :content_type => 'text/css'
       end
       cache_package if perform_caching
     rescue Jammit::PackageNotFound
@@ -57,12 +60,12 @@ module Jammit
       css
     end
 
-    # Extracts the package name, extension (:css, :js, :jst), and variant
-    # (:datauri, :mhtml) from the incoming URL.
+    # Extracts the package name, extension (:css, :js), and variant (:datauri,
+    # :mhtml) from the incoming URL.
     def parse_request
       pack       = params[:package]
       @extension = params[:extension].to_sym
-      raise PackageNotFound unless VALID_FORMATS.include?(@extension)
+      raise PackageNotFound unless (VALID_FORMATS + [Jammit.template_extension.to_sym]).include?(@extension)
       if Jammit.embed_assets
         suffix_match = pack.match(SUFFIX_STRIPPER)
         @variant = Jammit.embed_assets && suffix_match && suffix_match[1].to_sym
@@ -84,7 +87,7 @@ end
 # Make the Jammit::Controller available to Rails as a top-level controller.
 ::JammitController = Jammit::Controller
 
-if Rails.env.development?
+if defined?(Rails) && Rails.env.development?
   ActionController::Base.class_eval do
     append_before_filter { Jammit.reload! }
   end

data/lib/jammit/dependencies.rb

@@ -2,17 +2,14 @@
 require 'uri'
 require 'erb'
 require 'zlib'
+require 'yaml'
 require 'base64'
 require 'pathname'
 require 'fileutils'
 
 # Gem Dependencies:
-require 'rubygems'
-gem     'rails', '~> 2.0'
 require 'yui/compressor'
 require 'closure-compiler'
-require 'active_support'
-require 'active_support/core_ext/hash'
 
 # Load initial configuration before the rest of Jammit.
 Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH) if defined?(Rails)
@@ -23,6 +20,9 @@ require 'jammit/packager'
 
 # Jammit Rails Integration:
 if defined?(Rails)
-  require 'jammit/controller' # Rails will auto-load 'jammit/helper' for us.
+  require 'jammit/controller'
+  require 'jammit/helper'
+  require 'jammit/railtie'
   require 'jammit/routes'
-end
+end
+

data/lib/jammit/helper.rb

@@ -6,10 +6,10 @@ module Jammit
   # to the cached packages.
   module Helper
 
-    DATA_URI_START = "<!--[if (!IE)|(gte IE 8)]><!-->"
-    DATA_URI_END   = "<!--<![endif]-->"
-    MHTML_START    = "<!--[if lte IE 7]>"
-    MHTML_END      = "<![endif]-->"
+    DATA_URI_START = "<!--[if (!IE)|(gte IE 8)]><!-->" unless defined?(DATA_URI_START)
+    DATA_URI_END   = "<!--<![endif]-->"                unless defined?(DATA_URI_END)
+    MHTML_START    = "<!--[if lte IE 7]>"              unless defined?(MHTML_START)
+    MHTML_END      = "<![endif]-->"                    unless defined?(MHTML_END)
 
     # If embed_assets is turned on, writes out links to the Data-URI and MHTML
     # versions of the stylesheet package, otherwise the package is regular
@@ -18,8 +18,8 @@ module Jammit
       options = packages.extract_options!
       return individual_stylesheets(packages, options) unless Jammit.package_assets
       disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
-      return packaged_stylesheets(packages, options) if disabled || !Jammit.embed_assets
-      return embedded_image_stylesheets(packages, options)
+      return html_safe(packaged_stylesheets(packages, options)) if disabled || !Jammit.embed_assets
+      return html_safe(embedded_image_stylesheets(packages, options))
     end
 
     # Writes out the URL to the bundled and compressed javascript package,
@@ -28,18 +28,22 @@ module Jammit
       tags = packages.map do |pack|
         Jammit.package_assets ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
       end
-      javascript_include_tag(tags.flatten)
+      html_safe(javascript_include_tag(tags.flatten))
     end
 
     # Writes out the URL to the concatenated and compiled JST file -- we always
     # have to pre-process it, even in development.
     def include_templates(*packages)
-      javascript_include_tag(packages.map {|pack| Jammit.asset_url(pack, :jst) })
+      raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nYou can include your JST alongside your JS, and use include_javascripts."
     end
 
 
     private
 
+    def html_safe(string)
+      string.respond_to?(:html_safe) ? string.html_safe : string
+    end
+
     # HTML tags, in order, for all of the individual stylesheets.
     def individual_stylesheets(packages, options)
       tags_with_options(packages, options) {|p| Jammit.packager.individual_urls(p.to_sym, :css) }

data/lib/jammit/packager.rb

@@ -21,14 +21,12 @@ module Jammit
       @compressor = Compressor.new
       @force = false
       @config = {
-        :css => (Jammit.configuration[:stylesheets] || {}).symbolize_keys,
-        :js  => (Jammit.configuration[:javascripts] || {}).symbolize_keys,
-        :jst => (Jammit.configuration[:templates]   || {}).symbolize_keys
+        :css => (Jammit.configuration[:stylesheets] || {}),
+        :js  => (Jammit.configuration[:javascripts] || {})
       }
       @packages = {
         :css => create_packages(@config[:css]),
-        :js  => create_packages(@config[:js]),
-        :jst => create_packages(@config[:jst])
+        :js  => create_packages(@config[:js])
       }
     end
 
@@ -40,7 +38,6 @@ module Jammit
     def precache_all(output_dir=nil, base_url=nil)
       output_dir ||= File.join(PUBLIC_ROOT, Jammit.package_path)
       cacheable(:js, output_dir).each  {|p| cache(p, 'js',  pack_javascripts(p), output_dir) }
-      cacheable(:jst, output_dir).each {|p| cache(p, 'jst', pack_templates(p),  output_dir) }
       cacheable(:css, output_dir).each do |p|
         cache(p, 'css', pack_stylesheets(p), output_dir)
         if Jammit.embed_assets
@@ -87,10 +84,9 @@ module Jammit
 
     # Return the compiled contents of a JST package.
     def pack_templates(package)
-      @compressor.compile_jst(package_for(package, :jst)[:paths])
+      @compressor.compile_jst(package_for(package, :js)[:paths])
     end
 
-
     private
 
     # Look up a package asset list by name, raising an exception if the
@@ -110,30 +106,48 @@ module Jammit
     end
 
     # Return a list of all of the packages that should be cached. If "force" is
-    # true, this is all of them -- otherwise only the packages whose source
-    # files have changed since the last package build.
+    # true, this is all of them -- otherwise only the packages that are missing
+    # or whose source files have changed since the last package build.
     def cacheable(extension, output_dir)
       names = @packages[extension].keys
       return names if @force
+      config_mtime = File.mtime(Jammit.config_path)
       return names.select do |name|
-        pack    = package_for(name, extension)
-        cached  = File.join(output_dir, Jammit.filename(name, extension))
-        since   = File.exists?(cached) && File.mtime(cached)
-        !since || pack[:paths].any? {|src| File.mtime(src) > since }
+        pack        = package_for(name, extension)
+        cached      = [Jammit.filename(name, extension)]
+        cached.push Jammit.filename(name, extension, :datauri) if Jammit.embed_assets
+        cached.push Jammit.filename(name, extension, :mhtml) if Jammit.mhtml_enabled
+        cached.map! {|file| File.join(output_dir, file) }
+        if cached.any? {|file| !File.exists?(file) }
+          true
+        else
+          since = cached.map {|file| File.mtime(file) }.min
+          config_mtime > since || pack[:paths].any? {|src| File.mtime(src) > since }
+        end
       end
     end
 
-    # Compiles the list of assets that goes into each package. Runs an ordered
-    # list of Dir.globs, taking the merged unique result.
+    # Compiles the list of assets that goes into each package. Runs an
+    # ordered list of Dir.globs, taking the merged unique result.
+    # If there are JST files in this package we need to add an extra
+    # path for when package_assets is off (e.g. in a dev environment).
+    # This package (e.g. /assets/package-name.jst) will never exist as
+    # an actual file but will be dynamically generated by Jammit on
+    # every request.
     def create_packages(config)
       packages = {}
       return packages if !config
       config.each do |name, globs|
         globs                  ||= []
         packages[name]         = {}
-        paths                  = globs.map {|glob| glob_files(glob) }.flatten.uniq
+        paths                  = globs.flatten.uniq.map {|glob| glob_files(glob) }.flatten.uniq
         packages[name][:paths] = paths
-        packages[name][:urls]  = paths.map {|path| path.sub(PATH_TO_URL, '') }
+        if !paths.grep(Jammit.template_extension_matcher).empty?
+          packages[name][:urls] = paths.grep(JS_EXTENSION).map {|path| path.sub(PATH_TO_URL, '') }
+          packages[name][:urls] += [Jammit.asset_url(name, Jammit.template_extension)]
+        else
+          packages[name][:urls] = paths.map {|path| path.sub(PATH_TO_URL, '') }
+        end
       end
       packages
     end
@@ -145,4 +159,4 @@ module Jammit
 
   end
 
-end
+end

data/lib/jammit/railtie.rb

@@ -0,0 +1,14 @@
+# Rails 3 configuration via Railtie
+
+if defined?(Rails::Railtie)
+  module Jammit
+    class Railtie < Rails::Railtie
+
+      initializer :jammit_routes do |app|
+        # Add a Jammit route for the reloader.
+        app.routes_reloader.paths << File.join(File.dirname(__FILE__), "..", "..", "rails", "routes.rb")
+      end
+
+    end
+  end
+end

data/lib/jammit/routes.rb

@@ -1,5 +1,6 @@
 module Jammit
 
+  # Rails 2.x routing module. Rails 3.x routes are in rails/routes.rb.
   module Routes
 
     # Jammit uses a single route in order to slow down Rails' routing speed
@@ -7,8 +8,14 @@ module Jammit
     #   Jammit::Routes.draw(map)
     # Passing in the routing "map" object.
     def self.draw(map)
-      map.jammit "/#{Jammit.package_path}/:package.:extension",
-                 :controller => 'jammit', :action => 'package'
+      map.jammit "/#{Jammit.package_path}/:package.:extension", {
+        :controller => 'jammit',
+        :action => 'package',
+        :requirements => {
+          # A hack to allow extension to include "."
+          :extension => /.+/
+        }
+      }
     end
 
   end

data/lib/jammit.rb

@@ -4,13 +4,13 @@ $LOAD_PATH.push File.expand_path(File.dirname(__FILE__))
 # to all of the configuration options.
 module Jammit
 
-  VERSION               = "0.4.4"
+  VERSION               = "0.5.0"
 
   ROOT                  = File.expand_path(File.dirname(__FILE__) + '/..')
 
-  ASSET_ROOT            = File.expand_path(defined?(Rails) ? Rails.root : ".") unless defined?(ASSET_ROOT)
+  ASSET_ROOT            = File.expand_path((defined?(Rails) && Rails.root.to_s.length > 0) ? Rails.root : ".") unless defined?(ASSET_ROOT)
 
-  PUBLIC_ROOT           = defined?(Rails) ? Rails.public_path : File.join(ASSET_ROOT, 'public')
+  PUBLIC_ROOT           = (defined?(Rails) && Rails.public_path.to_s.length > 0) ? Rails.public_path : File.join(ASSET_ROOT, 'public') unless defined?(PUBLIC_ROOT)
 
   DEFAULT_CONFIG_PATH   = File.join(ASSET_ROOT, 'config', 'assets.yml')
 
@@ -26,6 +26,10 @@ module Jammit
 
   DEFAULT_COMPRESSOR    = :yui
 
+  # Extension matchers for JavaScript and JST, which need to be disambiguated.
+  JS_EXTENSION          = /\.js\Z/
+  DEFAULT_JST_EXTENSION = "jst"
+
   # Jammit raises a @PackageNotFound@ exception when a non-existent package is
   # requested by a browser -- rendering a 404.
   class PackageNotFound < NameError; end
@@ -38,11 +42,15 @@ module Jammit
   # cached packages is locked.
   class OutputNotWritable < StandardError; end
 
+  # Jammit raises a DeprecationError if you try to use an outdated feature.
+  class DeprecationError < StandardError; end
+
   class << self
     attr_reader :configuration, :template_function, :template_namespace,
                 :embed_assets, :package_assets, :compress_assets, :gzip_assets,
-                :package_path, :mhtml_enabled, :include_jst_script,
-                :javascript_compressor, :compressor_options, :css_compressor_options
+                :package_path, :mhtml_enabled, :include_jst_script, :config_path,
+                :javascript_compressor, :compressor_options, :css_compressor_options,
+                :template_extension, :template_extension_matcher
   end
 
   # The minimal required configuration.
@@ -55,19 +63,23 @@ module Jammit
     raise ConfigurationNotFound, "could not find the \"#{config_path}\" configuration file" unless exists
     conf = YAML.load(ERB.new(File.read(config_path)).result)
     @config_path            = config_path
-    @configuration          = conf = conf.symbolize_keys
+    @configuration          = symbolize_keys(conf)
     @package_path           = conf[:package_path] || DEFAULT_PACKAGE_PATH
     @embed_assets           = conf[:embed_assets] || conf[:embed_images]
     @compress_assets        = !(conf[:compress_assets] == false)
     @gzip_assets            = !(conf[:gzip_assets] == false)
     @mhtml_enabled          = @embed_assets && @embed_assets != "datauri"
-    @compressor_options     = (conf[:compressor_options] || {}).symbolize_keys
-    @css_compressor_options = (conf[:css_compressor_options] || {}).symbolize_keys
+    @compressor_options     = symbolize_keys(conf[:compressor_options] || {})
+    @css_compressor_options = symbolize_keys(conf[:css_compressor_options] || {})
     set_javascript_compressor(conf[:javascript_compressor])
     set_package_assets(conf[:package_assets])
     set_template_function(conf[:template_function])
     set_template_namespace(conf[:template_namespace])
+    set_template_extension(conf[:template_extension])
+    symbolize_keys(conf[:stylesheets]) if conf[:stylesheets]
+    symbolize_keys(conf[:javascripts]) if conf[:javascripts]
     check_java_version
+    check_for_deprecations
     self
   end
 
@@ -124,14 +136,22 @@ module Jammit
     @template_namespace = value == true || value.nil? ? DEFAULT_JST_NAMESPACE : value.to_s
   end
 
+  # Set the extension for JS templates.
+  def self.set_template_extension(value)
+    @template_extension = (value == true || value.nil? ? DEFAULT_JST_EXTENSION : value.to_s).gsub(/\A\.?(.*)\Z/, '\1')
+    @template_extension_matcher = /\.#{Regexp.escape(@template_extension)}\Z/
+  end
+
   # The YUI Compressor requires Java > 1.4, and Closure requires Java > 1.6.
   def self.check_java_version
+    return true if @checked_java_version
     java = @compressor_options[:java] || 'java'
     @css_compressor_options[:java] ||= java if @compressor_options[:java]
     version = (`#{java} -version 2>&1`)[/\d+\.\d+/]
     disable_compression if !version ||
       (@javascript_compressor == :closure && version < '1.6') ||
       (@javascript_compressor == :yui && version < '1.4')
+    @checked_java_version = true
   end
 
   # If we don't have a working Java VM, then disable asset compression and
@@ -141,6 +161,11 @@ module Jammit
     warn("Asset compression disabled -- Java unavailable.")
   end
 
+  # Jammit 0.5+ no longer supports separate template packages.
+  def self.check_for_deprecations
+    raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nPlease fold your templates into the appropriate 'javascripts' package instead." if @configuration[:templates]
+  end
+
   def self.warn(message)
     message = "Jammit Warning: #{message}"
     @logger ||= (defined?(Rails) && Rails.logger ? Rails.logger :
@@ -148,6 +173,15 @@ module Jammit
     @logger ? @logger.warn(message) : STDERR.puts(message)
   end
 
+  # Clone of active_support's symbolize_keys, so that we don't have to depend
+  # on active_support in any fashion. Converts a hash's keys to all symbols.
+  def self.symbolize_keys(hash)
+    hash.keys.each do |key|
+      hash[(key.to_sym rescue key) || key] = hash.delete(key)
+    end
+    hash
+  end
+
 end
 
 require 'jammit/dependencies'

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: jammit
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Jeremy Ashkenas
@@ -9,39 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-06 00:00:00 -05:00
+date: 2010-02-19 00:00:00 -05:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rails
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.0.0
-    version: 
 - !ruby/object:Gem::Dependency 
   name: yui-compressor
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 1
         version: 0.9.1
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: closure-compiler
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
         version: 0.1.0
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: "    Jammit is an industrial strength asset packaging library for Rails,\n    providing both the CSS and JavaScript concatenation and compression that\n    you'd expect, as well as YUI Compressor and Closure Compiler compatibility,\n    ahead-of-time gzipping, built-in JavaScript template support, and optional\n    Data-URI / MHTML image embedding.\n"
 email: jeremy@documentcloud.org
 executables: 
@@ -58,6 +61,7 @@ files:
 - lib/jammit/helper.rb
 - lib/jammit/jst.js
 - lib/jammit/packager.rb
+- lib/jammit/railtie.rb
 - lib/jammit/routes.rb
 - lib/jammit.rb
 - bin/jammit
@@ -83,18 +87,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: jammit
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Industrial Strength Asset Packaging for Rails