jammit 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Jeremy Ashkenas, DocumentCloud
+
+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

@@ -0,0 +1,21 @@
+==
+       _  _   __  __ __  __ ___ _____ 
+    _ | |/_\ |  \/  |  \/  |_ _|_   _|
+   | || / _ \| |\/| | |\/| || |  | |  
+    \__/_/ \_\_|  |_|_|  |_|___| |_|
+    
+    
+  Jammit is an industrial strength asset packaging library for Rails,
+  providing both the CSS and JavaScript concatenation and compression
+  that you'd expect, as well as ahead-of-time gzipping, built-in JavaScript
+  template support, and optional Data-URI / MHTML image embedding.
+  
+  For documentation, usage, and examples, see:
+  http://documentcloud.github.com/jammit/
+  
+  To suggest a feature or report a bug:
+  http://github.com/documentcloud/jammit/issues/
+  
+  For internal source docs, see:
+  http://documentcloud.github.com/jammit/doc/
+  

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake/testtask'
+
+desc 'Run all tests'
+task :test do
+  $LOAD_PATH.unshift(File.expand_path('test'))
+  require 'redgreen' if Gem.available?('redgreen')
+  require 'test/unit'
+  Dir['test/**/test_*.rb'].each {|test| require test }
+end
+
+desc 'Generate YARD Documentation'
+task :doc do
+  sh "mv README TEMPME"
+  sh "yardoc"
+  sh "mv TEMPME README"
+end
+
+desc "Deploy the Github Page"
+task :deploy do
+  sh "git co gh-pages && git merge master && git push github gh-pages && git co master"
+end
+
+namespace :gem do
+
+  desc 'Build and install the jammit gem'
+  task :install do
+    sh "gem build jammit.gemspec"
+    sh "sudo gem install #{Dir['*.gem'].join(' ')} --local --no-ri --no-rdoc"
+  end
+
+  desc 'Uninstall the jammit gem'
+  task :uninstall do
+    sh "sudo gem uninstall -x jammit"
+  end
+
+end
+
+task :default => :test

data/bin/jammit

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../lib/jammit/command_line.rb"
+
+Jammit::CommandLine.new

data/jammit.gemspec

@@ -0,0 +1,47 @@
+Gem::Specification.new do |s|
+  s.name      = 'jammit'
+  s.version   = '0.1.0'         # Keep version in sync with jammit.rb
+  s.date      = '2009-11-06'
+
+  s.homepage    = "http://documentcloud.github.com/jammit/"
+  s.summary     = "Industrial Strength Asset Packaging for Rails"
+  s.description = <<-EOS
+    Jammit is an industrial strength asset packaging library for Rails,
+    providing both the CSS and JavaScript concatenation and compression
+    that you'd expect, as well as ahead-of-time gzipping, built-in JavaScript
+    template support, and optional Data-URI / MHTML image embedding.
+  EOS
+
+  s.authors           = ['Jeremy Ashkenas']
+  s.email             = 'jeremy@documentcloud.org'
+  s.rubyforge_project = 'jammit'
+
+  s.require_paths     = ['lib']
+  s.executables       = ['jammit']
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = ['README']
+  s.rdoc_options      << '--title'    << 'Jammit' <<
+                         '--exclude'  << 'test' <<
+                         '--main'     << 'README' <<
+                         '--all'
+
+  s.add_dependency 'rails', ['>= 2.0.0']
+  s.add_dependency 'yui-compressor', ['>= 0.9.1']
+
+  s.files = %w(
+bin/jammit
+jammit.gemspec
+lib/jammit.rb
+lib/jammit/command_line.rb
+lib/jammit/compressor.rb
+lib/jammit/controller.rb
+lib/jammit/helper.rb
+lib/jammit/jst.js
+lib/jammit/packager.rb
+lib/jammit/routes.rb
+LICENSE
+Rakefile
+README
+)
+end

data/lib/jammit.rb

@@ -0,0 +1,117 @@
+$LOAD_PATH.push File.expand_path(File.dirname(__FILE__))
+
+# @Jammit@ is the central namespace for all Jammit classes, and provides access
+# to all of the configuration options.
+module Jammit
+
+  VERSION = "0.1.0"
+
+  ROOT = File.expand_path(File.dirname(__FILE__) + '/..')
+
+  DEFAULT_CONFIG_PATH  = "config/assets.yml"
+
+  DEFAULT_PACKAGE_PATH = "assets"
+
+  DEFAULT_JST_SCRIPT   = "#{ROOT}/lib/jammit/jst.js"
+
+  DEFAULT_JST_COMPILER = "template"
+
+  # Jammit raises a @PackageNotFound@ exception when a non-existent package is
+  # requested by a browser -- rendering a 404.
+  class PackageNotFound < NameError; end
+
+  class << self
+    attr_reader :configuration, :template_function, :embed_images, :package_path,
+                :package_assets, :mhtml_enabled, :include_jst_script
+  end
+
+  # The minimal required configuration.
+  @configuration = {}
+  @package_path  = DEFAULT_PACKAGE_PATH
+
+  # Load the complete asset configuration from the specified @config_path@.
+  def self.load_configuration(config_path)
+    return unless config_path && File.exists?(config_path)
+    @config_path        = config_path
+    @configuration      = conf = YAML.load_file(@config_path).symbolize_keys
+    @package_path       = conf[:package_path] || DEFAULT_PACKAGE_PATH
+    @embed_images       = conf[:embed_images]
+    @mhtml_enabled      = @embed_images && @embed_images != "datauri"
+    set_package_assets(conf[:package_assets])
+    set_template_function(conf[:template_function])
+    self
+  end
+
+  # Force a reload by resetting the Packager and reloading the configuration.
+  # In development, this will be called before every request to the
+  # @Jammit::Controller@.
+  def self.reload!
+    Thread.current[:jammit_packager] = nil
+    load_configuration(@config_path)
+  end
+
+  # Keep a global (thread-local) reference to a @Jammit::Packager@, to avoid
+  # recomputing asset lists unnecessarily.
+  def self.packager
+    Thread.current[:jammit_packager] ||= Packager.new
+  end
+
+  # Generate the base filename for a version of a given package.
+  def self.filename(package, extension, suffix=nil)
+    suffix_part  = suffix ? "-#{suffix}" : ''
+    "#{package}#{suffix_part}.#{extension}"
+  end
+
+  # Generates the server-absolute URL to an asset package.
+  def self.asset_url(package, extension, suffix=nil, mtime=nil)
+    timestamp = mtime ? "?#{mtime.to_i}" : ''
+    "/#{package_path}/#{filename(package, extension, suffix)}#{timestamp}"
+  end
+
+
+  private
+
+  def self.set_package_assets(value)
+    package_env     = !defined?(RAILS_ENV) || RAILS_ENV != 'development'
+    @package_assets = case value
+    when 'always'     then true
+    when false        then false
+    when true         then package_env
+    when nil          then package_env
+    end
+  end
+
+  def self.set_template_function(value)
+    @template_function = case value
+    when false then ''
+    when true  then DEFAULT_JST_COMPILER
+    when nil   then DEFAULT_JST_COMPILER
+    else            value
+    end
+    @include_jst_script = @template_function == DEFAULT_JST_COMPILER
+  end
+
+end
+
+# Standard Library Dependencies:
+require 'zlib'
+require 'base64'
+require 'fileutils'
+
+# Gem Dependencies:
+require 'rubygems'
+require 'yui/compressor'
+require 'activesupport'
+
+# Load initial configuration before the rest of Jammit.
+Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH)
+
+# Jammit Core:
+require 'jammit/compressor'
+require 'jammit/packager'
+
+# Jammit Rails Integration:
+if defined?(RAILS_ENV)
+  require 'jammit/controller' # Rails will auto-load 'jammit/helper' for us.
+  require 'jammit/routes'
+end

data/lib/jammit/command_line.rb

@@ -0,0 +1,74 @@
+require 'optparse'
+require File.expand_path(File.dirname(__FILE__) + '/../jammit')
+
+module Jammit
+
+  # The @CommandLine@ is able to compress, pre-package, and pre-gzip all the
+  # assets specified in the configuration file, in order to avoid an initial
+  # round of slow requests after a fresh deployment.
+  class CommandLine
+
+    BANNER = <<-EOS
+
+Usage: jammit OPTIONS
+
+Run jammit inside a Rails application to compresses all JS, CSS,
+and JST according to config/assets.yml, saving the packaged
+files and corresponding gzipped versions.
+
+If you're using "embed_images", and you wish to precompile the
+MHTML stylesheet variants, you must specify the "base-url".
+
+Options:
+    EOS
+
+    # The @Jammit::CommandLine@ runs from the contents of @ARGV@.
+    def initialize
+      parse_options
+      ensure_configuration_file
+      Jammit.load_configuration(@options[:config_path])
+      Jammit.packager.precache_all(@options[:output_folder], @options[:base_url])
+    end
+
+
+    private
+
+    # Make sure that we have a readable configuration file. The @jammit@
+    # command can't run without one.
+    def ensure_configuration_file
+      config = @options[:config_path]
+      return true if File.exists?(config) && File.readable?(config)
+      puts "Could not find the asset configuration file \"#{config}\""
+      exit(1)
+    end
+
+    # Uses @OptionParser@ to grab the options: *--output*, *--config*, and
+    # *--base-url*...
+    def parse_options
+      @options = {
+        :config_path => Jammit::DEFAULT_CONFIG_PATH,
+        :output_folder => nil,
+        :base_url => nil
+      }
+      @option_parser = OptionParser.new do |opts|
+        opts.on('-o', '--output PATH', 'output folder for packages (default: "public/assets")') do |output_folder|
+          @options[:output_folder] = output_folder
+        end
+        opts.on('-c', '--config PATH', 'path to assets.yml (default: "config/assets.yml")') do |config_path|
+          @options[:config_path] = config_path
+        end
+        opts.on('-u', '--base-url URL', 'base URL for MHTML (ex: "http://example.com")') do |base_url|
+          @options[:base_url] = base_url
+        end
+        opts.on_tail('-v', '--version', 'display Jammit version') do
+          puts "Jammit version #{Jammit::VERSION}"
+          exit
+        end
+      end
+      @option_parser.banner = BANNER
+      @option_parser.parse!(ARGV)
+    end
+
+  end
+
+end

data/lib/jammit/compressor.rb

@@ -0,0 +1,125 @@
+module Jammit
+
+  # Uses the YUI Compressor to compress JavaScript and CSS. (Which means that
+  # Java must be installed.) Also knows how to create a concatenated JST file.
+  # If "embed_images" is turned on, creates "mhtml" and "datauri" versions of
+  # all stylesheets, with all enabled images inlined into the css.
+  class Compressor
+
+    # Mapping from extension to mime-type of all embeddable images.
+    IMAGE_MIME_TYPES = {
+      '.png'  => 'image/png',
+      '.jpg'  => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif'  => 'image/gif',
+      '.tif'  => 'image/tiff',
+      '.tiff' => 'image/tiff'
+    }
+
+    # Detect all image URLs that are inside of an "embed" folder.
+    IMAGE_DETECTOR  = /url\(['"]?(\/[^\s)]*embed\/[^\s)]+\.(png|jpg|jpeg|gif|tif|tiff))['"]?\)/
+
+    # 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"
+
+    # JST file constants.
+    JST_START       = "(function(){window.JST = window.JST || {};"
+    JST_END         = "})();"
+
+    # Creating a compressor initializes the internal YUI Compressor from
+    # the "yui-compressor" gem.
+    def initialize
+      @yui_js  = YUI::JavaScriptCompressor.new(:munge => true)
+      @yui_css = YUI::CssCompressor.new
+    end
+
+    # Concatenate together a list of JavaScript paths, and pass them through the
+    # YUI Compressor (with munging enabled).
+    def compress_js(paths)
+      @yui_js.compress(concatenate(paths))
+    end
+
+    # Concatenate and compress a list of CSS stylesheets. When compressing a
+    # :datauri or :mhtml variant, post-processes the result to embed
+    # referenced images.
+    def compress_css(paths, variant=nil, asset_url=nil)
+      compressed_css = @yui_css.compress(concatenate(paths))
+      case variant
+      when nil      then compressed_css
+      when :datauri then with_data_uris(compressed_css)
+      when :mhtml   then with_mhtml(compressed_css, asset_url)
+      end
+    end
+
+    # Compiles a single JST file by writing out a javascript that adds
+    # template properties to a top-level "window.JST" object. Adds a
+    # JST-compilation function to the top of the package, unless you've
+    # specified your own preferred function, or turned it off.
+    # JST templates are named with the basename of their file.
+    def compile_jst(paths)
+      compiled = paths.map do |path|
+        template_name = File.basename(path, File.extname(path))
+        contents      = File.read(path).gsub(/\n/, '').gsub("'", '\\\\\'')
+        "window.JST.#{template_name} = #{Jammit.template_function}('#{contents}');"
+      end
+      compiler = Jammit.include_jst_script ? File.read(DEFAULT_JST_SCRIPT) : '';
+      [JST_START, compiler, compiled, JST_END].flatten.join("\n")
+    end
+
+
+    private
+
+    # Re-write all enabled image URLs in a stylesheet with their corresponding
+    # Data-URI Base-64 encoded image contents.
+    def with_data_uris(css)
+      css.gsub(IMAGE_DETECTOR) do |url|
+        image_path = "public#{$1}"
+        valid_image(image_path) ? "url(\"data:#{mime_type(image_path)};base64,#{encoded_contents(image_path)}\")" : url
+      end
+    end
+
+    # Re-write all enabled image URLs in a stylesheet with the MHTML equivalent.
+    # The newlines ("\r\n") in the following method are critical. Without them
+    # your MHTML will look identical, but won't work.
+    def with_mhtml(css, asset_url)
+      paths = {}
+      css = css.gsub(IMAGE_DETECTOR) do |url|
+        image_path = "public#{$1}"
+        valid = valid_image(image_path)
+        paths[$1] ||= image_path if valid
+        valid ? "url(mhtml:#{asset_url}!#{$1})" : url
+      end
+      mhtml = paths.map do |identifier, path|
+        mime, contents = mime_type(path), encoded_contents(path)
+        [MHTML_SEPARATOR, "Content-Location: #{identifier}\r\n", "Content-Type: #{mime}\r\n", "Content-Transfer-Encoding: base64\r\n\r\n", contents, "\r\n"]
+      end
+      [MHTML_START, mhtml, MHTML_END, css].flatten.join('')
+    end
+
+    # An image is valid if it exists, and is less than 32K.
+    # IE does not support Data-URIs larger than 32K, and you probably shouldn't
+    # be embedding images that large in any case.
+    def valid_image(image_path)
+      File.exists?(image_path) && File.size(image_path) < 32.kilobytes
+    end
+
+    # Return the Base64-encoded contents of an image on a single line.
+    def encoded_contents(image_path)
+      Base64.encode64(File.read(image_path)).gsub(/\n/, '')
+    end
+
+    # Grab the mime-type of an image, by filename.
+    def mime_type(image_path)
+      IMAGE_MIME_TYPES[File.extname(image_path)]
+    end
+
+    # Concatenate together a list of asset files.
+    def concatenate(paths)
+      [paths].flatten.map {|p| File.read(p) }.join("\n")
+    end
+
+  end
+
+end

data/lib/jammit/controller.rb

@@ -0,0 +1,91 @@
+module Jammit
+
+  # The JammitController is added to your Rails application when the Gem is
+  # loaded. It takes responsibility for /assets, and dynamically packages any
+  # missing or uncached asset packages.
+  class Controller < ActionController::Base
+
+    VALID_FORMATS   = [:css, :js, :jst]
+
+    SUFFIX_STRIPPER = /-(datauri|mhtml)\Z/
+
+    NOT_FOUND_PATH  = "#{RAILS_ROOT}/public/404.html"
+
+    after_filter :cache_package if perform_caching
+
+    # The "package" action receives all requests for asset packages that haven't
+    # yet been cached. The package will be built, cached, and gzipped.
+    def package
+      parse_request
+      case @extension
+      when :js  then render :js   => Jammit.packager.pack_javascripts(@package)
+      when :css then render :text => generate_stylesheets, :content_type => 'text/css'
+      when :jst then render :js   => Jammit.packager.pack_templates(@package)
+      end
+    rescue Jammit::PackageNotFound
+      package_not_found
+    end
+
+
+    private
+
+    # Tells the Jammit::Packager to cache and gzip an asset package. We can't
+    # just use the built-in "cache_page" because we need to ensure that
+    # the timestamp that ends up in the MHTML is also on the cached file.
+    def cache_package
+      dir = File.join(page_cache_directory, Jammit.package_path)
+      Jammit.packager.cache(@package, @extension, @contents || response.body, dir, @variant, @mtime)
+    end
+
+    # Generate the complete, timestamped, MHTML url -- if we're rendering a
+    # dynamic MHTML package, we'll need to put one URL in the response, and a
+    # different one into the cached package.
+    def prefix_url(path)
+      host = request.port == 80 ? request.host : request.host_with_port
+      "#{request.protocol}#{host}#{path}"
+    end
+
+    # If we're generating MHTML/CSS, return a stylesheet with the absolute
+    # request URL to the client, and cache a version with the timestamped cache
+    # URL swapped in.
+    def generate_stylesheets
+      return Jammit.packager.pack_stylesheets(@package, @variant) unless @variant == :mhtml
+      @mtime      = Time.now
+      request_url = prefix_url(request.request_uri)
+      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.
+    def parse_request
+      pack       = params[:package]
+      @extension = params[:extension].to_sym
+      raise PackageNotFound unless VALID_FORMATS.include?(@extension)
+      if Jammit.embed_images
+        suffix_match = pack.match(SUFFIX_STRIPPER)
+        @variant = Jammit.embed_images && suffix_match && suffix_match[1].to_sym
+        pack.sub!(SUFFIX_STRIPPER, '')
+      end
+      @package = pack.to_sym
+    end
+
+    # Render the 404 page, if one exists, for any packages that don't.
+    def package_not_found
+      return render(:file => NOT_FOUND_PATH, :status => 404) if File.exists?(NOT_FOUND_PATH)
+      render :text => "<h1>404: \"#{@package}\" asset package not found.</h1>", :status => 404
+    end
+
+  end
+
+end
+
+::JammitController = Jammit::Controller
+
+if RAILS_ENV == 'development'
+  class ApplicationController < ActionController::Base
+    before_filter { Jammit.reload! }
+  end
+end

data/lib/jammit/helper.rb

@@ -0,0 +1,66 @@
+module Jammit
+
+  # The Jammit::Helper module, which is made available to every view, provides
+  # helpers for writing out HTML tags for asset packages. In development you
+  # get the ordered list of source files -- in any other environment, a link
+  # 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]-->"
+
+    # If embed_images 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)
+      return individual_stylesheets(packages) unless Jammit.package_assets
+      return embedded_image_stylesheets(packages) if Jammit.embed_images
+      return packaged_stylesheets(packages)
+    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)
+      end
+      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) })
+    end
+
+
+    private
+
+    # HTML tags, in order, for all of the individual stylesheets.
+    def individual_stylesheets(packages)
+      stylesheet_link_tag(packages.map {|p| Jammit.packager.individual_urls(p.to_sym, :css) }.flatten)
+    end
+
+    # HTML tags for the stylesheet packages.
+    def packaged_stylesheets(packages)
+      stylesheet_link_tag(packages.map {|p| Jammit.asset_url(p, :css) })
+    end
+
+    # HTML tags for the 'datauri', and 'mhtml' versions of the packaged
+    # stylesheets, using conditional comments to load the correct variant.
+    def embedded_image_stylesheets(packages)
+      css_tags = stylesheet_link_tag(packages.map {|p| Jammit.asset_url(p, :css, :datauri) })
+      ie_tags = Jammit.mhtml_enabled ?
+        stylesheet_link_tag(packages.map {|p| Jammit.asset_url(p, :css, :mhtml) }) :
+        packaged_stylesheets(packages)
+      [DATA_URI_START, css_tags, DATA_URI_END, MHTML_START, ie_tags, MHTML_END].join("\n")
+    end
+
+  end
+
+end
+
+# Include the Jammit asset helpers in all views, a-la ApplicationHelper.
+::ActionView::Base.send(:include, Jammit::Helper)

data/lib/jammit/jst.js

@@ -0,0 +1 @@
+var template = function(str){var fn = new Function('obj', 'var p=[],print=function(){p.push.apply(p,arguments);};with(obj){p.push(\''+str.replace(/[\r\t\n]/g, " ").split("<%").join("\t").replace(/((^|%>)[^\t]*)'/g, "$1\r").replace(/\t=(.*?)%>/g, "',$1,'").split("\t").join("');").split("%>").join("p.push('").split("\r").join("\\'")+"');}return p.join('');"); return fn;};

data/lib/jammit/packager.rb

@@ -0,0 +1,113 @@
+module Jammit
+
+  # The Jammit::Packager resolves the configuration file into lists of real
+  # assets that get merged into individual asset packages. Given the compiled
+  # contents of an asset package, the Packager knows how to cache that package
+  # with the correct timestamps.
+  class Packager
+
+    # In Rails, the difference between a path and an asset URL is "public".
+    PATH_TO_URL = /\A\/?public/
+
+    # Creating a new Packager will rebuild the list of assets from the
+    # Jammit.configuration. When assets.yml is being changed on the fly,
+    # create a new Packager.
+    def initialize
+      @compressor = Compressor.new
+      @config = {
+        :css => (Jammit.configuration[:stylesheets] || {}).symbolize_keys,
+        :js  => (Jammit.configuration[:javascripts] || {}).symbolize_keys,
+        :jst => (Jammit.configuration[:templates]   || {}).symbolize_keys
+      }
+      @packages = {
+        :css => create_packages(@config[:css]),
+        :js  => create_packages(@config[:js]),
+        :jst => create_packages(@config[:jst])
+      }
+    end
+
+    # Ask the packager to precache all defined assets, along with their gzip'd
+    # versions. In order to prebuild the MHTML stylesheets, we need to know the
+    # base_url, because IE only supports MHTML with absolute references.
+    def precache_all(output_dir=nil, base_url=nil)
+      output_dir ||= "public/#{Jammit.package_path}"
+      @config[:js].keys.each  {|p| cache(p, 'js',  pack_javascripts(p), output_dir) }
+      @config[:jst].keys.each {|p| cache(p, 'jst', pack_templates(p),  output_dir) }
+      @config[:css].keys.each do |p|
+        cache(p, 'css', pack_stylesheets(p), output_dir)
+        if Jammit.embed_images
+          cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
+          if Jammit.mhtml_enabled && base_url
+            mtime = Time.now
+            asset_url = "#{base_url}#{Jammit.asset_url(p, :css, :mhtml, mtime)}"
+            cache(p, 'css', pack_stylesheets(p, :mhtml, asset_url), output_dir, :mhtml, mtime)
+          end
+        end
+      end
+    end
+
+    # Caches a single prebuilt asset package and gzips it at the highest
+    # compression level. Ensures that the modification time of both both
+    # variants is identical, for web server caching modules, as well as MHTML.
+    def cache(package, extension, contents, output_dir, suffix=nil, mtime=Time.now)
+      FileUtils.mkdir_p(output_dir) unless File.exists?(output_dir)
+      filename = File.join(output_dir, Jammit.filename(package, extension, suffix))
+      zip_name = "#{filename}.gz"
+      File.open(filename, 'wb+') {|f| f.write(contents) }
+      Zlib::GzipWriter.open(zip_name, Zlib::BEST_COMPRESSION) {|f| f.write(contents) }
+      File.utime(mtime, mtime, filename, zip_name)
+    end
+
+    # Get the list of individual assets for a package.
+    def individual_urls(package, extension)
+      package_for(package, extension)[:urls]
+    end
+
+    # Return the compressed contents of a stylesheet package.
+    def pack_stylesheets(package, variant=nil, asset_url=nil)
+      @compressor.compress_css(package_for(package, :css)[:paths], variant, asset_url)
+    end
+
+    # Return the compressed contents of a javascript package.
+    def pack_javascripts(package)
+      @compressor.compress_js(package_for(package, :js)[:paths])
+    end
+
+    # Return the compiled contents of a JST package.
+    def pack_templates(package)
+      @compressor.compile_jst(package_for(package, :jst)[:paths])
+    end
+
+
+    private
+
+    # Look up a package asset list by name, raising an exception if the
+    # package has gone missing.
+    def package_for(package, extension)
+      pack = @packages[extension] && @packages[extension][package]
+      pack || not_found(package, extension)
+    end
+
+    # Compiles the list of assets that goes into each package. Runs an ordered
+    # list of Dir.globs, taking the merged unique result.
+    def create_packages(config)
+      packages = {}
+      return packages if !config
+      config.each do |name, globs|
+        globs                  ||= []
+        packages[name]         = {}
+        paths                  = globs.map {|glob| Dir[glob] }.flatten.uniq
+        packages[name][:paths] = paths
+        packages[name][:urls]  = paths.map {|path| path.sub(PATH_TO_URL, '') }
+      end
+      packages
+    end
+
+    # Raise a PackageNotFound exception for missing packages...
+    def not_found(package, extension)
+      raise PackageNotFound, "assets.yml does not contain a \"#{package}\" #{extension.to_s.upcase} package"
+    end
+
+  end
+
+end

data/lib/jammit/routes.rb

@@ -0,0 +1,16 @@
+module Jammit
+
+  module Routes
+
+    # Jammit uses a single route in order to slow down Rails' routing speed
+    # by the absolute minimum. In your config/routes.rb file, call:
+    #   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'
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: jammit
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jeremy Ashkenas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-06 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 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    version: 
+description: "    Jammit is an industrial strength asset packaging library for Rails,\n    providing both the CSS and JavaScript concatenation and compression\n    that you'd expect, as well as ahead-of-time gzipping, built-in JavaScript\n    template support, and optional Data-URI / MHTML image embedding.\n"
+email: jeremy@documentcloud.org
+executables: 
+- jammit
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- bin/jammit
+- jammit.gemspec
+- lib/jammit.rb
+- lib/jammit/command_line.rb
+- lib/jammit/compressor.rb
+- lib/jammit/controller.rb
+- lib/jammit/helper.rb
+- lib/jammit/jst.js
+- lib/jammit/packager.rb
+- lib/jammit/routes.rb
+- LICENSE
+- Rakefile
+- README
+has_rdoc: true
+homepage: http://documentcloud.github.com/jammit/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Jammit
+- --exclude
+- test
+- --main
+- README
+- --all
+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: jammit
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Industrial Strength Asset Packaging for Rails
+test_files: []
+