ee_jammit 0.6.6

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NmU3NDMxYmYxYTg0M2QzZDA0MTQ0ZGE1NmNjNTJiMzU2ZjA2ZjljMw==
+  data.tar.gz: !binary |-
+    YWE3MmU3ZDQyYmI5NmM5MzNkNjU2ZmFjMjU2Y2Q4NTIyNDZkZGQ0Zg==
+SHA512:
+  metadata.gz: !binary |-
+    NDYyMTBmY2Y0OWYwYmIzNzUxZWViMDNmYTliZTI0YTRiZjNkNjk5MWE2ZTU2
+    MjNlOThhN2E2ZjZlMGQ5MWVmMzBmNmQ3NzE5M2ZlNjI2YzA0NzBmZGI5YTdj
+    MWFiNDAyMmNhNzFhOTdkNmQ0MWZjODliMTgyMGU5MTMzZjk1MWI=
+  data.tar.gz: !binary |-
+    YmE5NzA1M2E5N2ZhODc0MjVmZWU2NTk1ZDgwNDdkZThmMDRlNDdkODM4M2Zh
+    NGNjY2E4NTc4YTI5NGRmNWMzYWUwNGE1MmNkMWU4ZDliZmM5YTUxMmIzZTU4
+    NTU0YWJlY2RmOWVjMTA5NmU1NDkwMzY0MjE0YTBiNDY0ZjRiNTE=

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009-2011 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,7 @@
+#!/usr/bin/env ruby -rrubygems
+require 'pathname'
+
+APP_ROOT = File.dirname(Pathname.new(__FILE__).realpath)
+require File.join(APP_ROOT, '../lib/jammit/command_line.rb')
+
+Jammit::CommandLine.new

data/jammit.gemspec

@@ -0,0 +1,34 @@
+Gem::Specification.new do |s|
+  s.name      = 'ee_jammit'
+  s.version   = '0.6.6'         # Keep version in sync with jammit.rb
+  s.date      = '2011-11-30'
+
+  s.homepage    = "http://documentcloud.github.com/jammit/"
+  s.summary     = "Industrial Strength Asset Packaging for Rails"
+  s.description = <<-EOS
+    Enphase Fork to get the Rails 4 route compatibility
+    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','Brenda Strech']
+  s.email             = 'jeremy@documentcloud.org'
+  s.rubyforge_project = 'jammit'
+
+  s.require_paths     = ['lib']
+  s.executables       = ['jammit']
+
+  s.extra_rdoc_files  = ['README']
+  s.rdoc_options      << '--title'    << 'Jammit' <<
+                         '--exclude'  << 'test' <<
+                         '--main'     << 'README' <<
+                         '--all'
+
+  s.add_dependency 'cssmin', ['>= 1.0.2']
+  s.add_dependency 'jsmin',  ['>= 1.0.1']
+
+  s.files = Dir['lib/**/*', 'bin/*', 'rails/*', 'jammit.gemspec', 'LICENSE', 'README']
+end

data/lib/jammit.rb

@@ -0,0 +1,236 @@
+$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.6"
+
+  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)
+
+  DEFAULT_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"
+
+  JAVASCRIPT_COMPRESSORS        = [:jsmin, :yui, :closure, :uglifier]
+
+  DEFAULT_JAVASCRIPT_COMPRESSOR = :jsmin
+
+  CSS_COMPRESSORS               = [:cssmin, :yui, :sass]
+
+  DEFAULT_CSS_COMPRESSOR        = :cssmin
+
+  # 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 MissingConfiguration exception when you try to load the
+  # configuration of an assets.yml file that doesn't exist, or are missing
+  # a piece of required configuration.
+  class MissingConfiguration < 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,
+                  :css_compressor_options, :template_extension,
+                  :template_extension_matcher, :allow_debugging,
+                  :rewrite_relative_paths, :public_root
+    attr_accessor :javascript_compressors, :css_compressors
+  end
+
+  # The minimal required configuration.
+  @configuration  = {}
+  @public_root    = DEFAULT_PUBLIC_ROOT
+  @package_path   = DEFAULT_PACKAGE_PATH
+
+  @javascript_compressors = JAVASCRIPT_COMPRESSORS
+  @css_compressors        = CSS_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 MissingConfiguration, "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 : ENV['RAILS_ENV'] || "development")
+    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)
+    @rewrite_relative_paths = !(conf[:rewrite_relative_paths] == 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_css_compressor(conf[:css_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])
+    set_public_root(conf[:public_root]) if conf[:public_root]
+    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,
+      :public_root    => nil,
+      :force          => false
+    }.merge(options)
+    load_configuration(options[:config_path])
+    set_public_root(options[:public_root]) if options[:public_root]
+    packager.force         = options[:force]
+    packager.package_names = options[:package_names]
+    packager.precache_all(options[:output_folder], options[:base_url])
+  end
+
+  private
+
+  # Allows command-line definition of `PUBLIC_ROOT`, for those using Jammit
+  # outside of Rails.
+  def self.set_public_root(public_root=nil)
+    @public_root = public_root if public_root
+  end
+
+  # Ensure that the JavaScript compressor is a valid choice.
+  def self.set_javascript_compressor(value)
+    value = value && value.to_sym
+    @javascript_compressor = javascript_compressors.include?(value) ? value : DEFAULT_JAVASCRIPT_COMPRESSOR
+  end
+
+  # Ensure that the CSS compressor is a valid choice.
+  def self.set_css_compressor(value)
+    value = value && value.to_sym
+    @css_compressor = css_compressors.include?(value) ? value : DEFAULT_CSS_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,84 @@
+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 LIST', 'list of packages to build (ex: "core,ui", default: all)') do |package_names|
+          @options[:package_names] = package_names.split(/,\s*/).map {|n| n.to_sym }
+        end
+        opts.on('-P', '--public-root PATH', 'path to public assets (default: "public")') do |public_root|
+          puts "Option for PUBLIC_ROOT"
+          @options[:public_root] = public_root
+        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,266 @@
+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'  => 'application/x-font-ttf',
+      '.otf'  => 'font/opentype',
+      '.woff' => 'application/x-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         = "})();"
+
+    JAVASCRIPT_COMPRESSORS = {
+      :jsmin    => Jammit.javascript_compressors.include?(:jsmin)  ? Jammit::JsminCompressor : nil,
+      :yui      => Jammit.javascript_compressors.include?(:yui)  ? YUI::JavaScriptCompressor : nil,
+      :closure  => Jammit.javascript_compressors.include?(:closure)  ? Closure::Compiler : nil,
+      :uglifier => Jammit.javascript_compressors.include?(:uglifier) ? Jammit::Uglifier  : nil
+    }
+
+    CSS_COMPRESSORS = {
+      :cssmin   => Jammit.css_compressors.include?(:cssmin) ? Jammit::CssminCompressor : nil,
+      :yui      => Jammit.css_compressors.include?(:yui) ? YUI::CssCompressor : nil,
+      :sass     => Jammit.css_compressors.include?(:sass) ? Jammit::SassCompressor : nil
+     }
+
+    JAVASCRIPT_DEFAULT_OPTIONS = {
+      :jsmin    => {},
+      :yui      => {:munge => true},
+      :closure  => {},
+      :uglifier => {:copyright => false}
+    }
+
+    # CSS compression can be provided with YUI Compressor or sass. JS
+    # compression can be provided with YUI Compressor, Google Closure
+    # Compiler or UglifyJS.
+    def initialize
+      if Jammit.javascript_compressors.include?(:yui) || Jammit.javascript_compressors.include?(:closure) || Jammit.css_compressors.include?(:yui)
+        Jammit.check_java_version
+      end
+
+      css_flavor      = Jammit.css_compressor || Jammit::DEFAULT_CSS_COMPRESSOR
+      @css_compressor = CSS_COMPRESSORS[css_flavor].new(Jammit.css_compressor_options || {})
+      js_flavor       = Jammit.javascript_compressor || Jammit::DEFAULT_JAVASCRIPT_COMPRESSOR
+      @options        = JAVASCRIPT_DEFAULT_OPTIONS[js_flavor].merge(Jammit.compressor_options || {})
+      @js_compressor  = JAVASCRIPT_COMPRESSORS[js_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.
+    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|
+        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? || ! Jammit.rewrite_relative_paths ? 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(Jammit.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(Jammit.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:UTF-8') {|f| f.read }
+    end
+  end
+
+end