altly-jammit 0.6.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,24 @@
+==
+       _  _   __  __ __  __ ___ _____ 
+    _ | |/_\ |  \/  |  \/  |_ _|_   _|
+   | || / _ \| |\/| | |\/| || |  | |  
+    \__/_/ \_\_|  |_|_|  |_|___| |_|
+    
+    
+  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.
+  
+  Installation:
+  gem install jammit
+  
+  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/bin/jammit

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

data/jammit.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name      = 'altly-jammit'
+  s.version   = '0.6.0'         # 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"
+  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 YUI Compressor and Closure Compiler compatibility,
+    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 'yui-compressor',    ['>= 0.9.3']
+
+  s.files = Dir['lib/**/*', 'bin/*', 'rails/*', 'jammit.gemspec', 'LICENSE', 'README']
+end

data/lib/jammit.rb

@@ -0,0 +1,209 @@
+$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.6.0"
+
+  ROOT                  = File.expand_path(File.dirname(__FILE__) + '/..')
+
+  ASSET_ROOT            = File.expand_path((defined?(Rails) && Rails.root.to_s.length > 0) ? Rails.root : ENV['RAILS_ROOT'] || ".") unless defined?(ASSET_ROOT)
+
+  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')
+
+  DEFAULT_PACKAGE_PATH  = "assets"
+
+  DEFAULT_JST_SCRIPT    = File.join(ROOT, 'lib/jammit/jst.js')
+
+  DEFAULT_JST_COMPILER  = "template"
+
+  DEFAULT_JST_NAMESPACE = "window.JST"
+
+  COMPRESSORS           = [:yui, :closure, :uglifier]
+
+  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
+
+  # Jammit raises a ConfigurationNotFound exception when you try to load the
+  # configuration of an assets.yml file that doesn't exist.
+  class ConfigurationNotFound < NameError; end
+
+  # Jammit raises an OutputNotWritable exception if the output directory for
+  # 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, :config_path,
+                  :javascript_compressor, :compressor_options, :css_compressor_options,
+                  :template_extension, :template_extension_matcher, :allow_debugging
+    attr_accessor :compressors
+  end
+
+  # The minimal required configuration.
+  @configuration  = {}
+  @package_path   = DEFAULT_PACKAGE_PATH
+  @compressors    = COMPRESSORS
+
+  # Load the complete asset configuration from the specified @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)
+
+    # Optionally overwrite configuration based on the environment.
+    rails_env = defined?(Rails) ? Rails.env : RAILS_ENV
+    conf.merge! conf.delete rails_env if conf.has_key? rails_env
+
+    @config_path            = config_path
+    @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     = 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_for_deprecations
+    self
+  end
+
+  # Force a reload by resetting the Packager and reloading the configuration.
+  # In development, this will be called as a before_filter before every request.
+  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
+
+  # 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.package_names = options[:package_names]
+    packager.precache_all(options[:output_folder], options[:base_url])
+  end
+
+  private
+
+  # Ensure that the JavaScript compressor is a valid choice.
+  def self.set_javascript_compressor(value)
+    value = value && value.to_sym
+    @javascript_compressor = compressors.include?(value) ? value : DEFAULT_COMPRESSOR
+  end
+
+  # Turn asset packaging on or off, depending on configuration and environment.
+  def self.set_package_assets(value)
+    package_env     = !defined?(Rails) || (!Rails.env.development? && !Rails.env.test?)
+    @package_assets = value == true || value.nil? ? package_env :
+                      value == 'always'           ? true : false
+  end
+
+  # Assign the JST template function, unless explicitly turned off.
+  def self.set_template_function(value)
+    @template_function = value == true || value.nil? ? DEFAULT_JST_COMPILER :
+                         value == false              ? '' : value
+    @include_jst_script = @template_function == DEFAULT_JST_COMPILER
+  end
+
+  # Set the root JS object in which to stash all compiled JST.
+  def self.set_template_namespace(value)
+    @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
+  # complain loudly.
+  def self.disable_compression
+    @compress_assets = false
+    warn("Asset compression disabled -- Java unavailable.")
+  end
+
+  # Jammit 0.5+ no longer supports separate template packages.
+  def self.check_for_deprecations
+    if @configuration[:templates]
+      raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nPlease fold your templates into the appropriate 'javascripts' package instead."
+    end
+  end
+
+  def self.warn(message)
+    message = "Jammit Warning: #{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'

data/lib/jammit/command_line.rb

@@ -0,0 +1,80 @@
+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_assets", 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.package!(@options)
+    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,
+        :force          => false
+      }
+      @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('-f', '--force', 'force a rebuild of all assets') do |force|
+          @options[:force] = force
+        end
+        opts.on('-p', '--packages PACKAGE_NAMES', 'comma-separated list of packages (ex: "core,embed", default: all packages)') do |package_names|
+          @options[:package_names] = package_names.split(/,\s*/).map {|n| n.to_sym }
+        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,253 @@
+module Jammit
+
+  # Uses the YUI Compressor or Closure Compiler to compress JavaScript.
+  # Always uses YUI to compress CSS (Which means that Java must be installed.)
+  # Also knows how to create a concatenated JST file.
+  # If "embed_assets" is turned on, creates "mhtml" and "datauri" versions of
+  # all stylesheets, with all enabled assets inlined into the css.
+  class Compressor
+
+    # Mapping from extension to mime-type of all embeddable assets.
+    EMBED_MIME_TYPES = {
+      '.png'  => 'image/png',
+      '.jpg'  => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif'  => 'image/gif',
+      '.tif'  => 'image/tiff',
+      '.tiff' => 'image/tiff',
+      '.ttf'  => 'font/truetype',
+      '.otf'  => 'font/opentype',
+      '.woff' => 'font/woff'
+    }
+
+    # Font extensions for which we allow embedding:
+    EMBED_EXTS      = EMBED_MIME_TYPES.keys
+    EMBED_FONTS     = ['.ttf', '.otf', '.woff']
+
+    # (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__(.+?)(\?\d+)?\)/
+
+    # MHTML file constants.
+    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(){"
+    JST_END         = "})();"
+
+    COMPRESSORS = {
+      :yui      => YUI::JavaScriptCompressor,
+      :closure  => Jammit.compressors.include?(:closure)  ? Closure::Compiler : nil,
+      :uglifier => Jammit.compressors.include?(:uglifier) ? Jammit::Uglifier  : nil
+    }
+
+    DEFAULT_OPTIONS = {
+      :yui      => {:munge => true},
+      :closure  => {},
+      :uglifier => {:copyright => false}
+    }
+
+    # The css compressor is always the YUI Compressor. JS compression can be
+    # provided with YUI Compressor, Google Closure Compiler or UglifyJS.
+    def initialize
+      Jammit.check_java_version
+      @css_compressor = YUI::CssCompressor.new(Jammit.css_compressor_options || {})
+      flavor          = Jammit.javascript_compressor || Jammit::DEFAULT_COMPRESSOR
+      @options        = DEFAULT_OPTIONS[flavor].merge(Jammit.compressor_options || {})
+      @js_compressor  = COMPRESSORS[flavor].new(@options)
+    end
+
+    # Concatenate together a list of JavaScript paths, and pass them through the
+    # YUI Compressor (with munging enabled). JST can optionally be included.
+    def compress_js(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
+
+    # Concatenate and compress a list of CSS stylesheets. When compressing a
+    # :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
+      when nil      then return css
+      when :datauri then return with_data_uris(css)
+      when :mhtml   then return with_mhtml(css, asset_url)
+      else raise PackageNotFound, "\"#{variant}\" is not a valid stylesheet variant"
+      end
+    end
+
+    # Compiles a single JST file by writing out a javascript that adds
+    # template properties to a top-level template namespace 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)
+      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(/\r?\n/, "\\n").gsub("'", '\\\\\'')
+        name      = template_name(path, base_path)
+        "#{namespace}['#{name}'] = #{Jammit.template_function}('#{contents}');"
+      end
+      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
+
+
+    private
+
+    # Given a set of paths, find a common prefix path.
+    # always makes sure its relative to client_side directory
+    def find_base_path(paths)
+      pieces = paths.first.split('/')
+      f = 0
+      pieces.each_with_index do |p,index|
+        if p == 'client_side'
+          f = index
+        end
+      end
+      r = pieces.slice(0,f+1).join('/')
+      return r
+    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|
+        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)})"
+        end
+      end
+      stylesheets.join("\n")
+    end
+
+    # Re-write all enabled asset URLs in a stylesheet with their corresponding
+    # Data-URI Base-64 encoded asset contents.
+    def with_data_uris(css)
+      css.gsub(EMBED_REPLACER) do |url|
+        "url(\"data:#{mime_type($1)};charset=utf-8;base64,#{encoded_contents($1)}\")"
+      end
+    end
+
+    # Re-write all enabled asset 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, index = {}, 0
+      css = css.gsub(EMBED_REPLACER) do |url|
+        i = paths[$1] ||= "#{index += 1}-#{File.basename($1)}"
+        "url(mhtml:#{asset_url}!#{i})"
+      end
+      mhtml = paths.sort.map do |path, identifier|
+        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
+
+    # Return a rewritten asset URL for a new stylesheet -- the asset should
+    # be tagged for embedding if embeddable, and referenced at the correct level
+    # if relative.
+    def construct_asset_path(asset_path, css_path, variant)
+      public_path = absolute_path(asset_path, css_path)
+      return "__EMBED__#{public_path}" if embeddable?(public_path, variant)
+      source = asset_path.absolute? ? asset_path.to_s : relative_path(public_path)
+      rewrite_asset_path(source, public_path)
+    end
+
+    # Get the site-absolute public path for an asset file path that may or may
+    # not be relative, given the path of the stylesheet that contains it.
+    def absolute_path(asset_pathname, css_pathname)
+      (asset_pathname.absolute? ?
+        Pathname.new(File.join(PUBLIC_ROOT, asset_pathname)) :
+        css_pathname.dirname + asset_pathname).cleanpath
+    end
+
+    # CSS assets that are referenced by relative paths, and are *not* being
+    # embedded, must be rewritten relative to the newly-merged stylesheet path.
+    def relative_path(absolute_path)
+      File.join('../', absolute_path.sub(PUBLIC_ROOT, ''))
+    end
+
+    # Similar to the AssetTagHelper's method of the same name, this will
+    # 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 || asset_id == '') ? path : "#{path}?#{asset_id}"
+    end
+
+    # Similar to the AssetTagHelper's method of the same name, this will
+    # determine the correct asset id for a file.
+    def rails_asset_id(path)
+      asset_id = ENV["RAILS_ASSET_ID"]
+      return asset_id if asset_id
+      File.exists?(path) ? File.mtime(path).to_i.to_s : ''
+    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. 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 || encoded_contents(asset_path).length < MAX_IMAGE_SIZE
+      return false if font && variant == :mhtml
+      return true
+    end
+
+    # Return the Base64-encoded contents of an asset on a single line.
+    def encoded_contents(asset_path)
+      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.
+    def mime_type(asset_path)
+      EMBED_MIME_TYPES[File.extname(asset_path)]
+    end
+
+    # Concatenate together a list of asset files.
+    def concatenate(paths)
+      [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

@@ -0,0 +1,97 @@
+require 'action_controller'
+
+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]
+
+    SUFFIX_STRIPPER = /-(datauri|mhtml)\Z/
+
+    NOT_FOUND_PATH  = "#{PUBLIC_ROOT}/404.html"
+
+    # 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
+      template_ext = Jammit.template_extension.to_sym
+      case @extension
+      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 && (@extension != template_ext)
+    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, 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 @contents = Jammit.packager.pack_stylesheets(@package, @variant) unless @variant == :mhtml
+      @mtime      = Time.now
+      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), and variant (:datauri,
+    # :mhtml) from the incoming URL.
+    def parse_request
+      pack       = params[:package]
+      @extension = params[:extension].to_sym
+      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
+        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
+
+# Make the Jammit::Controller available to Rails as a top-level controller.
+::JammitController = Jammit::Controller
+
+if defined?(Rails) && Rails.env.development?
+  ActionController::Base.class_eval do
+    append_before_filter { Jammit.reload! }
+  end
+end

data/lib/jammit/dependencies.rb

@@ -0,0 +1,42 @@
+# Standard Library Dependencies:
+require 'uri'
+require 'erb'
+require 'zlib'
+require 'yaml'
+require 'base64'
+require 'pathname'
+require 'fileutils'
+
+# Include YUI as the default
+require 'yui/compressor'
+
+# Try Closure.
+begin
+  require 'closure-compiler'
+rescue LoadError
+  Jammit.compressors.delete :closure
+end
+
+# Try Uglifier.
+begin
+  require 'uglifier'
+rescue LoadError
+  Jammit.compressors.delete :uglifier
+end
+
+# Load initial configuration before the rest of Jammit.
+Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH, true) if defined?(Rails)
+
+# Jammit Core:
+require 'jammit/uglifier' if Jammit.compressors.include? :uglifier
+require 'jammit/compressor'
+require 'jammit/packager'
+
+# Jammit Rails Integration:
+if defined?(Rails)
+  require 'jammit/controller'
+  require 'jammit/helper'
+  require 'jammit/railtie'
+  require 'jammit/routes'
+end
+

data/lib/jammit/helper.rb

@@ -0,0 +1,85 @@
+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)]><!-->" 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 should_package?
+      disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
+      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|
+        should_package? ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
+      end
+      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)
+      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) }
+    end
+
+    # HTML tags for the stylesheet packages.
+    def packaged_stylesheets(packages, options)
+      tags_with_options(packages, options) {|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, options)
+      datauri_tags = tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :datauri) }
+      ie_tags = Jammit.mhtml_enabled ?
+                tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :mhtml) } :
+                packaged_stylesheets(packages, options)
+      [DATA_URI_START, datauri_tags, DATA_URI_END, MHTML_START, ie_tags, MHTML_END].join("\n")
+    end
+
+    # Generate the stylesheet tags for a batch of packages, with options, by
+    # yielding each package to a block.
+    def tags_with_options(packages, options)
+      packages = packages.dup
+      packages.map! {|package| yield package }.flatten!
+      packages.push(options) unless options.empty?
+      stylesheet_link_tag(*packages)
+    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, " ").replace(/'(?=[^%]*%>)/g,"\t").split("'").join("\\'").split("\t").join("'").replace(/<%=(.+?)%>/g,"',$1,'").split("<%").join("');").split("%>").join("p.push('")+"');}return p.join('');"); return fn;};

data/lib/jammit/packager.rb

@@ -0,0 +1,164 @@
+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_DIFF   = PUBLIC_ROOT.sub(ASSET_ROOT, '')
+    PATH_TO_URL = /\A#{Regexp.escape(ASSET_ROOT)}(\/?#{Regexp.escape(PATH_DIFF)})?/
+
+    # Set force to false to allow packages to only be rebuilt when their source
+    # files have changed since the last time their package was built.
+    attr_accessor :force, :package_names
+
+    # 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
+      @force          = false
+      @package_names  = nil
+      @config = {
+        :css => (Jammit.configuration[:stylesheets] || {}),
+        :js  => (Jammit.configuration[:javascripts] || {})
+      }
+      @packages = {
+        :css => create_packages(@config[:css]),
+        :js  => create_packages(@config[:js])
+      }
+    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.
+    # Unless forced, will only rebuild assets whose source files have been
+    # changed since their last package build.
+    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(:css, output_dir).each do |p|
+        cache(p, 'css', pack_stylesheets(p), output_dir)
+        if Jammit.embed_assets
+          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)
+      raise OutputNotWritable, "Jammit doesn't have permission to write to \"#{output_dir}\"" unless File.writable?(output_dir)
+      files = []
+      files << file_name = File.join(output_dir, Jammit.filename(package, extension, suffix))
+      File.open(file_name, 'wb+') {|f| f.write(contents) }
+      if Jammit.gzip_assets
+        files << zip_name = "#{file_name}.gz"
+        Zlib::GzipWriter.open(zip_name, Zlib::BEST_COMPRESSION) {|f| f.write(contents) }
+      end
+      File.utime(mtime, mtime, *files)
+    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, :js)[: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
+
+    # Absolute globs are absolute -- relative globs are relative to ASSET_ROOT.
+    # Print a warning if no files were found that match the glob.
+    def glob_files(glob)
+      absolute = Pathname.new(glob).absolute?
+      paths = Dir[absolute ? glob : File.join(ASSET_ROOT, glob)].sort
+      Jammit.warn("No assets match '#{glob}'") if paths.empty?
+      paths
+    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 that are missing
+    # or whose source files have changed since the last package build.
+    def cacheable(extension, output_dir)
+      names = @packages[extension].keys
+      names = names.select {|n| @package_names.include? n } if @package_names
+      config_mtime = File.mtime(Jammit.config_path)
+      return names if @force
+      return names.select do |name|
+        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.
+    # 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.flatten.uniq.map {|glob| glob_files(glob) }.flatten.uniq
+        packages[name][:paths] = paths
+        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
+
+    # 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/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

@@ -0,0 +1,23 @@
+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
+    # 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',
+        :requirements => {
+          # A hack to allow extension to include "."
+          :extension => /.+/
+        }
+      }
+    end
+
+  end
+
+end

data/lib/jammit/uglifier.rb

@@ -0,0 +1,3 @@
+class Jammit::Uglifier < ::Uglifier
+  alias :compress :compile
+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

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: altly-jammit
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.6.0
+platform: ruby
+authors: 
+- Jeremy Ashkenas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yui-compressor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.3
+  type: :runtime
+  version_requirements: *id001
+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: 
+- jammit
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/jammit/command_line.rb
+- lib/jammit/compressor.rb
+- lib/jammit/controller.rb
+- lib/jammit/dependencies.rb
+- lib/jammit/helper.rb
+- lib/jammit/jst.js
+- lib/jammit/packager.rb
+- lib/jammit/railtie.rb
+- lib/jammit/routes.rb
+- lib/jammit/uglifier.rb
+- lib/jammit.rb
+- bin/jammit
+- rails/routes.rb
+- jammit.gemspec
+- LICENSE
+- 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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: jammit
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Industrial Strength Asset Packaging for Rails
+test_files: []
+