ghazel-jammit 0.4.4.3 → 0.6.0.1

data/jammit.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name      = 'ghazel-jammit'
-  s.version   = '0.4.4.3'         # Keep version in sync with jammit.rb
-  s.date      = '2010-2-6'
+  s.version   = '0.6.0.1'         # Keep version in sync with jammit.rb
+  s.date      = '2010-11-8'
 
   s.homepage    = "http://documentcloud.github.com/jammit/"
   s.summary     = "Industrial Strength Asset Packaging for Rails"
@@ -27,9 +27,8 @@ 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 'ghazel-closure-compiler',  ['>= 0.2.0.2']
+  s.add_dependency 'ghazel-yui-compressor',    ['>= 0.9.4.2']
+  s.add_dependency 'closure-compiler',  ['>= 0.1.0']
 
-  s.files = Dir['lib/**/*', 'bin/*', 'jammit.gemspec', 'LICENSE', 'README']
-end
+  s.files = Dir['lib/**/*', 'bin/*', 'rails/*', 'jammit.gemspec', 'LICENSE', 'README']
+end

data/lib/jammit/command_line.rb

@@ -26,9 +26,7 @@ Options:
     def initialize
       parse_options
       ensure_configuration_file
-      Jammit.load_configuration(@options[:config_path])
-      Jammit.packager.force = @options[:force]
-      Jammit.packager.precache_all(@options[:output_folder], @options[:base_url])
+      Jammit.package!(@options)
     end
 
 

data/lib/jammit/compressor.rb

@@ -16,25 +16,26 @@ module Jammit
       '.tif'  => 'image/tiff',
       '.tiff' => 'image/tiff',
       '.ttf'  => 'font/truetype',
-      '.otf'  => 'font/opentype'
+      '.otf'  => 'font/opentype',
+      '.woff' => 'font/woff'
     }
 
     # Font extensions for which we allow embedding:
     EMBED_EXTS      = EMBED_MIME_TYPES.keys
-    EMBED_FONTS     = ['.ttf', '.otf']
+    EMBED_FONTS     = ['.ttf', '.otf', '.woff']
 
-    # 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 +62,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 +76,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,13 +93,16 @@ 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  = read_binary_file(path)
+        contents  = contents.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) : '';
+      compiler = Jammit.include_jst_script ? read_binary_file(DEFAULT_JST_SCRIPT) : '';
       setup_namespace = "#{namespace} = #{namespace} || {};"
       [JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
     end
@@ -101,13 +110,35 @@ 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#{Regexp.escape(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
     # at it.
     def concatenate_and_tag_assets(paths, variant=nil)
       stylesheets = [paths].flatten.map do |css_path|
-        File.read(css_path).gsub(EMBED_DETECTOR) do |url|
+        contents = read_binary_file(css_path)
+        contents.gsub(EMBED_DETECTOR) do |url|
           ipath, cpath = Pathname.new($1), Pathname.new(File.expand_path(css_path))
           is_url = URI.parse($1).absolute?
           is_url ? url : "url(#{construct_asset_path(ipath, cpath, variant)})"
@@ -168,7 +199,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 +211,25 @@ 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/, '')
+      return @asset_contents[asset_path] if @asset_contents[asset_path]
+      data = read_binary_file(asset_path)
+      @asset_contents[asset_path] = Base64.encode64(data).gsub(/\n/, '')
     end
 
     # Grab the mime-type of an asset, by filename.
@@ -206,9 +239,13 @@ module Jammit
 
     # Concatenate together a list of asset files.
     def concatenate(paths)
-      [paths].flatten.map {|p| File.read(p) }.join("\n")
+      [paths].flatten.map {|p| read_binary_file(p) }.join("\n")
     end
 
+    # `File.read`, but in "binary" mode.
+    def read_binary_file(path)
+      File.open(path, 'rb') {|f| f.read }
+    end
   end
 
 end

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/
 
@@ -15,12 +15,16 @@ module Jammit
     # yet been cached. The package will be built, cached, and gzipped.
     def package
       parse_request
+      template_ext = Jammit.template_extension.to_sym
       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 template_ext
+        render :js => (@contents = Jammit.packager.pack_templates(@package))
+      when :css
+        render :text => generate_stylesheets, :content_type => 'text/css'
       end
-      cache_package if perform_caching
+      cache_package if perform_caching && (@extension != template_ext)
     rescue Jammit::PackageNotFound
       package_not_found
     end
@@ -50,19 +54,19 @@ module Jammit
     def generate_stylesheets
       return @contents = Jammit.packager.pack_stylesheets(@package, @variant) unless @variant == :mhtml
       @mtime      = Time.now
-      request_url = prefix_url(request.request_uri)
+      request_url = prefix_url(request.fullpath)
       cached_url  = prefix_url(Jammit.asset_url(@package, @extension, @variant, @mtime))
       css         = Jammit.packager.pack_stylesheets(@package, @variant, request_url)
       @contents   = css.gsub(request_url, cached_url) if perform_caching
       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 +88,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,20 +2,17 @@
 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)
+Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH, true) if defined?(Rails)
 
 # Jammit Core:
 require 'jammit/compressor'
@@ -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,40 +6,48 @@ 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
     # compressed CSS, and in development the stylesheet URLs are passed verbatim.
     def include_stylesheets(*packages)
       options = packages.extract_options!
-      return individual_stylesheets(packages, options) unless Jammit.package_assets
+      return individual_stylesheets(packages, options) unless should_package?
       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,
     # except in development, where it references the individual scripts.
     def include_javascripts(*packages)
       tags = packages.map do |pack|
-        Jammit.package_assets ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
+        should_package? ? 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 should_package?
+      Jammit.package_assets && !(Jammit.allow_debugging && params[:debug_assets])
+    end
+
+    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,6 +1,6 @@
 module Jammit
 
-  # Rails 2.x routing module.
+  # 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
@@ -8,18 +8,16 @@ 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
 
-end
-
-# Rails 3.x routes.
-if defined?(Jammit::Railtie)
-  Jammit::Railtie.routes do
-    match "/#{Jammit.package_path}/:package.:extension",
-      :to => 'jammit#package', :as => 'jammit'
-  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.6.0.1"
 
   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, :allow_debugging
   end
 
   # The minimal required configuration.
@@ -50,24 +58,31 @@ module Jammit
   @package_path  = DEFAULT_PACKAGE_PATH
 
   # Load the complete asset configuration from the specified @config_path@.
-  def self.load_configuration(config_path)
+  # If we're loading softly, don't let missing configuration error out.
+  def self.load_configuration(config_path, soft=false)
     exists = config_path && File.exists?(config_path)
+    return false if soft && !exists
     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)
+    @allow_debugging        = !(conf[:allow_debugging] == 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
 
@@ -96,6 +111,18 @@ module Jammit
     "/#{package_path}/#{filename(package, extension, suffix)}#{timestamp}"
   end
 
+  # Convenience method for packaging up Jammit, using the default options.
+  def self.package!(options={})
+    options = {
+      :config_path    => Jammit::DEFAULT_CONFIG_PATH,
+      :output_folder  => nil,
+      :base_url       => nil,
+      :force          => false
+    }.merge(options)
+    load_configuration(options[:config_path])
+    packager.force = options[:force]
+    packager.precache_all(options[:output_folder], options[:base_url])
+  end
 
   private
 
@@ -107,7 +134,7 @@ module Jammit
 
   # Turn asset packaging on or off, depending on configuration and environment.
   def self.set_package_assets(value)
-    package_env     = !defined?(Rails) || !Rails.env.development?
+    package_env     = !defined?(Rails) || (!Rails.env.development? && !Rails.env.test?)
     @package_assets = value == true || value.nil? ? package_env :
                       value == 'always'           ? true : false
   end
@@ -124,6 +151,12 @@ 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
@@ -143,11 +176,23 @@ 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 :
-                 defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil)
-    @logger ? @logger.warn(message) : STDERR.puts(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

data/rails/routes.rb

@@ -0,0 +1,10 @@
+if defined?(Rails::Application)
+  # Rails3 routes
+  Rails.application.routes.draw do
+    match "/#{Jammit.package_path}/:package.:extension",
+      :to => 'jammit#package', :as => :jammit, :constraints => {
+        # A hack to allow extension to include "."
+        :extension => /.+/
+      }
+  end
+end

metadata

@@ -1,7 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: ghazel-jammit
 version: !ruby/object:Gem::Version 
-  version: 0.4.4.3
+  hash: 125
+  prerelease: 
+  segments: 
+  - 0
+  - 6
+  - 0
+  - 1
+  version: 0.6.0.1
 platform: ruby
 authors: 
 - Jeremy Ashkenas
@@ -9,39 +16,42 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-06 00:00:00 -08:00
+date: 2010-11-08 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rails
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: ghazel-yui-compressor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.0.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: yui-compressor
+        hash: 19
+        segments: 
+        - 0
+        - 9
+        - 4
+        - 2
+        version: 0.9.4.2
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.1
-    version: 
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: ghazel-closure-compiler
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: closure-compiler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.2.0.2
-    version: 
+        hash: 27
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  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,9 +68,11 @@ 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
+- rails/routes.rb
 - jammit.gemspec
 - LICENSE
 - README
@@ -80,21 +92,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: jammit
-rubygems_version: 1.3.5
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Industrial Strength Asset Packaging for Rails