agibralter-jammit 0.5.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,35 @@
+Gem::Specification.new do |s|
+  s.name      = 'agibralter-jammit'
+  s.version   = '0.5.0'         # Keep version in sync with jammit.rb
+  s.date      = '2010-04-30'
+
+  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 'rails',             ['>= 2.0.0']
+  s.add_dependency 'yui-compressor',    ['>= 0.9.1']
+  s.add_dependency 'closure-compiler',  ['>= 0.1.0']
+
+  s.files = Dir['lib/**/*', 'bin/*', 'jammit.gemspec', 'LICENSE', 'README']
+end

data/lib/jammit.rb

@@ -0,0 +1,183 @@
+$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.5.0"
+
+  ROOT                  = File.expand_path(File.dirname(__FILE__) + '/..')
+
+  ASSET_ROOT            = File.expand_path(defined?(Rails) ? Rails.root : ".") unless defined?(ASSET_ROOT)
+
+  PUBLIC_ROOT           = defined?(Rails) ? Rails.public_path : File.join(ASSET_ROOT, 'public')
+
+  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"
+
+  AVAILABLE_COMPRESSORS = [:yui, :closure]
+
+  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,
+                :javascript_compressor, :compressor_options, :css_compressor_options,
+                :jst_extension, :jst_extension_regexp, :template_base_path
+  end
+
+  # The minimal required configuration.
+  @configuration = {}
+  @package_path  = DEFAULT_PACKAGE_PATH
+
+  # Load the complete asset configuration from the specified @config_path@.
+  def self.load_configuration(config_path)
+    exists = config_path && File.exists?(config_path)
+    raise ConfigurationNotFound, "could not find the \"#{config_path}\" configuration file" unless exists
+    conf = YAML.load(ERB.new(File.read(config_path)).result)
+    @config_path            = config_path
+    @configuration          = conf = conf.symbolize_keys
+    @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)
+    @mhtml_enabled          = @embed_assets && @embed_assets != "datauri"
+    @compressor_options     = (conf[:compressor_options] || {}).symbolize_keys
+    @css_compressor_options = (conf[:css_compressor_options] || {}).symbolize_keys
+    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])
+    set_template_base_path(conf[:template_base_path])
+    check_java_version
+    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
+
+
+  private
+
+  # Ensure that the JavaScript compressor is a valid choice.
+  def self.set_javascript_compressor(value)
+    value = value && value.to_sym
+    @javascript_compressor = AVAILABLE_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?
+    @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)
+    @jst_extension = (value == true || value.nil? ? DEFAULT_JST_EXTENSION : value.to_s).gsub(/\A\.?(.*)\Z/, '.\1')
+    @jst_extension_regexp = /#{Regexp.escape(@jst_extension)}\Z/
+  end
+
+  def self.set_template_base_path(value)
+    if (@template_base_path = value == true || value.nil? ? nil : Pathname.new(value.to_s)) && !@template_base_path.absolute?
+      @template_base_path = Pathname.new(ASSET_ROOT) + @template_base_path
+    end
+  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
+    raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nPlease fold your templates into the appropriate 'javascripts' package instead." if @configuration[:templates]
+  end
+
+  def self.warn(message)
+    message = "Jammit Warning: #{message}"
+    @logger ||= (defined?(Rails) && Rails.logger ? Rails.logger :
+                 defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil)
+    @logger ? @logger.warn(message) : STDERR.puts(message)
+  end
+
+end
+
+require 'jammit/dependencies'

data/lib/jammit/command_line.rb

@@ -0,0 +1,79 @@
+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.load_configuration(@options[:config_path])
+      Jammit.packager.force = @options[:force]
+      Jammit.packager.precache_all(@options[:output_folder], @options[:base_url])
+    end
+
+
+    private
+
+    # Make sure that we have a readable configuration file. The @jammit@
+    # command can't run without one.
+    def ensure_configuration_file
+      config = @options[:config_path]
+      return true if File.exists?(config) && File.readable?(config)
+      puts "Could not find the asset configuration file \"#{config}\""
+      exit(1)
+    end
+
+    # Uses @OptionParser@ to grab the options: *--output*, *--config*, and
+    # *--base-url*...
+    def parse_options
+      @options = {
+        :config_path    => Jammit::DEFAULT_CONFIG_PATH,
+        :output_folder  => nil,
+        :base_url       => nil,
+        :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_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,222 @@
+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'
+    }
+
+    # Font extensions for which we allow embedding:
+    EMBED_EXTS      = EMBED_MIME_TYPES.keys
+    EMBED_FONTS     = ['.ttf', '.otf']
+
+    # 32k maximum size for embeddable images (an IE8 limitation).
+    MAX_IMAGE_SIZE  = 32768
+
+    # CSS asset-embedding regexes for URL rewriting.
+    EMBED_DETECTOR  = /url\(['"]?([^\s)]+\.[a-z]+)(\?\d+)?['"]?\)/
+    EMBEDDABLE      = /[\A\/]embed\//
+    EMBED_REPLACER  = /url\(__EMBED__([^\s)]+)(\?\d+)?\)/
+
+    # MHTML file constants.
+    MHTML_START     = "/*\r\nContent-Type: multipart/related; boundary=\"JAMMIT_MHTML_SEPARATOR\"\r\n\r\n"
+    MHTML_SEPARATOR = "--JAMMIT_MHTML_SEPARATOR\r\n"
+    MHTML_END       = "*/\r\n"
+
+    # JST file constants.
+    JST_START       = "(function(){"
+    JST_END         = "})();"
+
+    COMPRESSORS = {
+      :yui     => YUI::JavaScriptCompressor,
+      :closure => Closure::Compiler
+    }
+
+    DEFAULT_OPTIONS = {
+      :yui     => {:munge => true},
+      :closure => {}
+    }
+
+    # Creating a compressor initializes the internal YUI Compressor from
+    # the "yui-compressor" gem, or the internal Closure Compiler from the
+    # "closure-compiler" gem.
+    def initialize
+      @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.jst_extension_regexp)).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)
+      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
+      compiled = paths.grep(Jammit.jst_extension_regexp).map do |path|
+        contents      = File.read(path).gsub(/\n/, '').gsub("'", '\\\\\'')
+        template_name = File.basename(path, Jammit.jst_extension)
+        if Jammit.template_base_path
+          path = Pathname.new(path)
+          template_name = path.parent().relative_path_from(Jammit.template_base_path) + template_name
+        end
+        "#{namespace}['#{template_name}'] = #{Jammit.template_function}('#{contents}');"
+      end
+      compiler = Jammit.include_jst_script ? File.read(DEFAULT_JST_SCRIPT) : '';
+      setup_namespace = "#{namespace} = #{namespace} || {};"
+      [JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
+    end
+
+
+    private
+
+    # In order to support embedded assets from relative paths, we need to
+    # expand the paths before contatenating the CSS together and losing the
+    # location of the original stylesheet path. Validate the assets while we're
+    # at it.
+    def concatenate_and_tag_assets(paths, variant=nil)
+      stylesheets = [paths].flatten.map do |css_path|
+        File.read(css_path).gsub(EMBED_DETECTOR) do |url|
+          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.blank? ? 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.
+    def embeddable?(asset_path, variant)
+      font = EMBED_FONTS.include?(asset_path.extname)
+      return false unless variant
+      return false unless asset_path.to_s.match(EMBEDDABLE) && asset_path.exist?
+      return false unless EMBED_EXTS.include?(asset_path.extname)
+      return false unless font || asset_path.size < MAX_IMAGE_SIZE
+      return false if font && variant == :mhtml
+      true
+    end
+
+    # Return the Base64-encoded contents of an asset on a single line.
+    def encoded_contents(asset_path)
+      data = File.open(asset_path, 'rb'){|f| f.read }
+      Base64.encode64(data).gsub(/\n/, '')
+    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| File.read(p) }.join("\n")
+    end
+
+  end
+
+end

data/lib/jammit/controller.rb

@@ -0,0 +1,96 @@
+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
+      case @extension
+      when :js
+        if @package.to_s =~ /\A(.*)__templates__\Z/
+          render :js => (@contents = Jammit.packager.pack_templates($~[1].to_sym))
+        else
+          render :js => (@contents = Jammit.packager.pack_javascripts(@package))
+        end
+      when :css
+        render :text => generate_stylesheets, :content_type => 'text/css'
+      end
+      cache_package if perform_caching
+    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.request_uri)
+      cached_url  = prefix_url(Jammit.asset_url(@package, @extension, @variant, @mtime))
+      css         = Jammit.packager.pack_stylesheets(@package, @variant, request_url)
+      @contents   = css.gsub(request_url, cached_url) if perform_caching
+      css
+    end
+
+    # Extracts the package name, extension (:css, :js), and variant (:datauri,
+    # :mhtml) from the incoming URL.
+    def parse_request
+      pack       = params[:package]
+      @extension = params[:extension].to_sym
+      raise PackageNotFound unless VALID_FORMATS.include?(@extension)
+      if Jammit.embed_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,28 @@
+# Standard Library Dependencies:
+require 'uri'
+require 'erb'
+require 'zlib'
+require 'base64'
+require 'pathname'
+require 'fileutils'
+
+# Gem Dependencies:
+require 'rubygems'
+gem     'rails', '~> 2.0'
+require 'yui/compressor'
+require 'closure-compiler'
+require 'active_support'
+require 'active_support/core_ext/hash'
+
+# Load initial configuration before the rest of Jammit.
+Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH) if defined?(Rails)
+
+# Jammit Core:
+require 'jammit/compressor'
+require 'jammit/packager'
+
+# Jammit Rails Integration:
+if defined?(Rails)
+  require 'jammit/controller' # Rails will auto-load 'jammit/helper' for us.
+  require 'jammit/routes'
+end

data/lib/jammit/helper.rb

@@ -0,0 +1,77 @@
+module Jammit
+
+  # The Jammit::Helper module, which is made available to every view, provides
+  # helpers for writing out HTML tags for asset packages. In development you
+  # get the ordered list of source files -- in any other environment, a link
+  # to the cached packages.
+  module Helper
+
+    DATA_URI_START = "<!--[if (!IE)|(gte IE 8)]><!-->"
+    DATA_URI_END   = "<!--<![endif]-->"
+    MHTML_START    = "<!--[if lte IE 7]>"
+    MHTML_END      = "<![endif]-->"
+
+    # If embed_assets is turned on, writes out links to the Data-URI and MHTML
+    # versions of the stylesheet package, otherwise the package is regular
+    # compressed CSS, and in development the stylesheet URLs are passed verbatim.
+    def include_stylesheets(*packages)
+      options = packages.extract_options!
+      return individual_stylesheets(packages, options) unless Jammit.package_assets
+      disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
+      return packaged_stylesheets(packages, options) if disabled || !Jammit.embed_assets
+      return embedded_image_stylesheets(packages, options)
+    end
+
+    # Writes out the URL to the bundled and compressed javascript package,
+    # except in development, where it references the individual scripts.
+    def include_javascripts(*packages)
+      tags = packages.map do |pack|
+        Jammit.package_assets ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
+      end
+      javascript_include_tag(tags.flatten)
+    end
+
+    # Writes out the URL to the concatenated and compiled JST file -- we always
+    # have to pre-process it, even in development.
+    def include_templates(*packages)
+      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
+
+    # 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,155 @@
+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
+
+    # 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
+      @config = {
+        :css => (Jammit.configuration[:stylesheets] || {}).symbolize_keys,
+        :js  => (Jammit.configuration[:javascripts] || {}).symbolize_keys
+      }
+      @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 whose source
+    # files have changed since the last package build.
+    def cacheable(extension, output_dir)
+      names = @packages[extension].keys
+      return names if @force
+      return names.select do |name|
+        pack    = package_for(name, extension)
+        cached  = File.join(output_dir, Jammit.filename(name, extension))
+        since   = File.exists?(cached) && File.mtime(cached)
+        !since || pack[:paths].any? {|src| File.mtime(src) > since }
+      end
+    end
+
+    # Compiles the list of assets that goes into each package. Runs an ordered
+    # list of Dir.globs, taking the merged unique result.
+    def create_packages(config)
+      packages = {}
+      return packages if !config
+      config.each do |name, globs|
+        globs                  ||= []
+        packages[name]         = {}
+        paths                  = globs.flatten.uniq.map {|glob| glob_files(glob) }.flatten.uniq
+        packages[name][:paths] = paths
+        # Check for JST.
+        if !paths.grep(Jammit.jst_extension_regexp).empty?
+          # 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__templates__.js) will
+          # never exist as an actual file but will be dynamically generated by
+          # Jammit on every request.
+          packages[name][:urls] = paths.grep(JS_EXTENSION).map {|path| path.sub(PATH_TO_URL, '') }
+          packages[name][:urls] += [Jammit.asset_url("#{name}__templates__", :js)]
+        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/routes.rb

@@ -0,0 +1,25 @@
+module Jammit
+
+  # Rails 2.x routing module.
+  module Routes
+
+    # Jammit uses a single route in order to slow down Rails' routing speed
+    # by the absolute minimum. In your config/routes.rb file, call:
+    #   Jammit::Routes.draw(map)
+    # Passing in the routing "map" object.
+    def self.draw(map)
+      map.jammit "/#{Jammit.package_path}/:package.:extension",
+                 :controller => 'jammit', :action => 'package'
+    end
+
+  end
+
+end
+
+# Rails 3.x routes.
+if defined?(Jammit::Railtie)
+  Jammit::Railtie.routes do
+    match "/#{Jammit.package_path}/:package.:extension",
+      :to => 'jammit#package', :as => 'jammit'
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification 
+name: agibralter-jammit
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Jeremy Ashkenas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-30 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yui-compressor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 1
+        version: 0.9.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: closure-compiler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id003
+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/routes.rb
+- lib/jammit.rb
+- bin/jammit
+- 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 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: jammit
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Industrial Strength Asset Packaging for Rails
+test_files: []
+