jammit-ebtd 0.6.6

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-ebtd.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name      = 'jammit-ebtd'
+  s.date      = '2012-09-04'
+  s.version   = '0.6.6'
+
+  s.homepage    = "https://github.com/m16a1/jammit-ebtd"
+  s.summary     = "Industrial Strength Asset Packaging for Rails"
+  s.description = <<-EOS
+    Jammit-Ebtd is a fork of the Jammit asset packager, modified for ebaytoday.ru
+  EOS
+
+  s.authors           = ['Jeremy Ashkenas']
+  s.email             = 'jeremy@documentcloud.org'
+
+  s.require_paths     = ['lib']
+
+  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/*', 'jammit-ebtd.gemspec', 'LICENSE', 'README']
+end

data/lib/jammit-ebtd.rb

@@ -0,0 +1,241 @@
+$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
+
+  def self.set_conf_dir(dir)
+    remove_const 'DEFAULT_CONFIG_PATH'
+    const_set 'DEFAULT_CONFIG_PATH', File.join(ASSET_ROOT, dir, 'assets.yml')
+  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,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'  => '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)
+      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)
+    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
+    # 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

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  = "#{Jammit.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/cssmin_compressor.rb

@@ -0,0 +1,10 @@
+# Wraps CSSMin compressor to use the same API as the rest of
+# Jammit's compressors.
+class Jammit::CssminCompressor
+  def initialize(options = {})
+  end
+
+  def compress(css)
+    CSSMin.minify(css)
+  end
+end

data/lib/jammit/dependencies.rb

@@ -0,0 +1,59 @@
+# Standard Library Dependencies:
+require 'uri'
+require 'erb'
+require 'zlib'
+require 'yaml'
+require 'base64'
+require 'pathname'
+require 'fileutils'
+
+# Try Uglifier.
+begin
+  require 'uglifier'
+  require 'jammit/uglifier'
+rescue LoadError
+  Jammit.javascript_compressors.delete :uglifier
+end
+
+# Try YUI
+begin
+  require 'yui/compressor'
+rescue LoadError
+  Jammit.javascript_compressors.delete :yui
+  Jammit.css_compressors.delete :yui
+end
+
+# Try Closure.
+begin
+  require 'closure-compiler'
+rescue LoadError
+  Jammit.javascript_compressors.delete :closure
+end
+
+# Try Sass
+begin
+  require 'sass'
+  require 'jammit/sass_compressor'
+rescue LoadError
+  Jammit.css_compressors.delete :sass
+end
+
+# Load initial configuration before the rest of Jammit.
+Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH, true) if defined?(Rails)
+
+# Jammit Core:
+require 'jsmin'
+require 'cssmin'
+require 'jammit/jsmin_compressor'
+require 'jammit/cssmin_compressor'
+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,88 @@
+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 html_safe(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)
+      options = packages.extract_options!
+      html_safe packages.map {|pack|
+        should_package? ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
+      }.flatten.map {|pack|
+        javascript_include_tag pack, options
+      }.join("\n")
+    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.dup.map {|package|
+        yield package
+      }.flatten.map {|package|
+        stylesheet_link_tag package, options
+      }.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/jsmin_compressor.rb

@@ -0,0 +1,10 @@
+# Wraps JSMin compressor to use the same API as the rest of
+# Jammit's compressors.
+class Jammit::JsminCompressor
+  def initialize(options = {})
+  end
+
+  def compress(js)
+    JSMin.minify(js)
+  end
+end

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(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/<%=([\s\S]+?)%>/g,function(match,code){return "',"+code.replace(/\\'/g, "'")+",'";}).replace(/<%([\s\S]+?)%>/g,function(match,code){return "');"+code.replace(/\\'/g, "'").replace(/[\r\n\t]/g,' ')+"__p.push('";}).replace(/\r/g,'\\r').replace(/\n/g,'\\n').replace(/\t/g,'\\t')+"');}return __p.join('');");return fn;};

data/lib/jammit/packager.rb

@@ -0,0 +1,201 @@
+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
+
+    # 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
+      @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(Jammit.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
+            raise MissingConfiguration, "A --base-url option is required in order to generate MHTML." unless base_url
+            mtime = latest_mtime package_for(p, :css)[:paths]
+            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=nil)
+      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)
+      mtime ||= latest_mtime package_for(package, extension.to_sym)[:paths]
+      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
+
+    def compressor
+      @compressor ||= Compressor.new
+    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)]
+      #Jammit.warn("No assets match '#{glob}'") if paths.empty?
+      paths
+    end
+
+    # In Rails, the difference between a path and an asset URL is "public".
+    def path_to_url
+      @path_to_url ||= /\A#{Regexp.escape(ASSET_ROOT)}(\/?#{Regexp.escape(Jammit.public_root.sub(ASSET_ROOT, ''))})?/
+    end
+
+    # Get the latest mtime of a list of files (plus the config path).
+    def latest_mtime(paths)
+      paths += [Jammit.config_path]
+      paths.map {|p| File.mtime(p) }.max || Time.now
+    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)]
+        if extension == :css
+          cached.push Jammit.filename(name, extension, :datauri) if Jammit.embed_assets
+          cached.push Jammit.filename(name, extension, :mhtml) if Jammit.mhtml_enabled
+        end
+        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 = get_file_list(globs.flatten.uniq).uniq.sort
+        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
+        puts name
+      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
+
+    private
+    def get_file_list(globs)
+      paths = []
+      globs.each do |glob|
+        if String === glob
+          paths.concat glob_files(glob)
+        elsif Hash === glob
+          paths = exclude_paths(paths, glob['exclude']) if glob['exclude']
+          #puts exclude_paths(paths, glob['exclude']).to_s
+        end
+      end
+      paths
+    end
+
+    def exclude_paths(paths, globs)
+      globs.each do |glob|
+        excluded_files = glob_files(glob)
+        paths.reject! { |path| excluded_files.include?(path) }
+      end
+      paths
+    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/sass_compressor.rb

@@ -0,0 +1,17 @@
+# Wraps sass' css compressor to use the same API as the rest of
+# Jammit's compressors.
+class Jammit::SassCompressor
+  # Creates a new sass compressor. Jammit::SassCompressor doesn't use
+  # any options, the +options+ parameter is there for API
+  # compatibility.
+  def initialize(options = {})
+  end
+
+  # Compresses +css+ using sass' CSS parser, and returns the
+  # compressed css.
+  def compress(css)
+    root_node = ::Sass::SCSS::CssParser.new(css, 'test.sass').parse
+    root_node.options = {:style => :compressed}
+    root_node.render.strip
+  end
+end

data/lib/jammit/uglifier.rb

@@ -0,0 +1,3 @@
+class Jammit::Uglifier < ::Uglifier
+  alias :compress :compile
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: jammit-ebtd
+version: !ruby/object:Gem::Version
+  version: 0.6.6
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Ashkenas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cssmin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: jsmin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+description: ! '    Jammit-Ebtd is a fork of the Jammit asset packager, modified for
+  ebaytoday.ru
+
+'
+email: jeremy@documentcloud.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- lib/jammit/uglifier.rb
+- lib/jammit/routes.rb
+- lib/jammit/compressor.rb
+- lib/jammit/jsmin_compressor.rb
+- lib/jammit/packager.rb
+- lib/jammit/railtie.rb
+- lib/jammit/dependencies.rb
+- lib/jammit/command_line.rb
+- lib/jammit/jst.js
+- lib/jammit/controller.rb
+- lib/jammit/sass_compressor.rb
+- lib/jammit/cssmin_compressor.rb
+- lib/jammit/helper.rb
+- lib/jammit-ebtd.rb
+- bin/jammit
+- jammit-ebtd.gemspec
+- LICENSE
+- README
+homepage: https://github.com/m16a1/jammit-ebtd
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Industrial Strength Asset Packaging for Rails
+test_files: []