ram 0.0.1

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.md

@@ -0,0 +1,19 @@
+== Ram
+
+Ram is an asset packaging library, written in Ruby.  It is entirely taken from the Jammit gem, but stripped of any Rails dependencies or helpers.  It was primarily written for packaging nanoc assets, though I suppose it could be used for many types of web development projects.
+
+Installation:
+  
+    gem install ram
+    
+Documentation, usage, and examples:
+
+  hmmm
+  
+To suggest a feature or report a bug:
+
+  hmmm
+  
+For source documentation:
+
+  one more

data/bin/ram

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

data/lib/ram.rb

@@ -0,0 +1,216 @@
+$LOAD_PATH.push File.expand_path(File.dirname(__FILE__))
+
+# @Ram@ is the central namespace for all Ram classes, and provides access
+# to all of the configuration options.
+module Ram
+
+  VERSION               = "0.6.3"
+
+  ROOT                  = File.expand_path(File.dirname(__FILE__) + '/..')
+
+  ASSET_ROOT            = '.' unless defined?(ASSET_ROOT)
+
+  DEFAULT_PUBLIC_ROOT   = 'output' 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/ram/jst.js')
+
+  DEFAULT_JST_COMPILER  = "template"
+
+  DEFAULT_JST_NAMESPACE = "window.JST"
+
+  COMPRESSORS           = [:yui, :closure, :uglifier]
+
+  DEFAULT_COMPRESSOR    = :yui
+
+  # Extension matchers for JavaScript and JST, which need to be disambiguated.
+  JS_EXTENSION          = /\.js\Z/
+  DEFAULT_JST_EXTENSION = "jst"
+
+  # Ram raises a @PackageNotFound@ exception when a non-existent package is
+  # requested by a browser -- rendering a 404.
+  class PackageNotFound < NameError; end
+
+  # Ram 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
+
+  # Ram raises an OutputNotWritable exception if the output directory for
+  # cached packages is locked.
+  class OutputNotWritable < StandardError; end
+
+  # Ram raises a DeprecationError if you try to use an outdated feature.
+  class DeprecationError < StandardError; end
+
+  class << self
+    attr_reader   :configuration, :template_function, :template_namespace,
+                  :embed_assets, :package_assets, :compress_assets, :gzip_assets,
+                  :package_path, :mhtml_enabled, :include_jst_script, :config_path,
+                  :javascript_compressor, :compressor_options, :css_compressor_options,
+                  :template_extension, :template_extension_matcher, :allow_debugging,
+                  :public_root
+    attr_accessor :compressors
+  end
+
+  # The minimal required configuration.
+  @configuration  = {}
+  @public_root    = DEFAULT_PUBLIC_ROOT
+  @package_path   = DEFAULT_PACKAGE_PATH
+  @compressors    = COMPRESSORS
+
+  # Load the complete asset configuration from the specified @config_path@.
+  # If we're loading softly, don't let missing configuration error out.
+  def self.load_configuration(config_path, soft=false)
+    exists = config_path && File.exists?(config_path)
+    return false if soft && !exists
+    raise MissingConfiguration, "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          = symbolize_keys(conf)
+    @package_path           = conf[:package_path] || DEFAULT_PACKAGE_PATH
+    @embed_assets           = conf[:embed_assets] || conf[:embed_images]
+    @compress_assets        = !(conf[:compress_assets] == false)
+    @gzip_assets            = !(conf[:gzip_assets] == false)
+    @allow_debugging        = !(conf[:allow_debugging] == false)
+    @mhtml_enabled          = @embed_assets && @embed_assets != "datauri"
+    @compressor_options     = symbolize_keys(conf[:compressor_options] || {})
+    @css_compressor_options = symbolize_keys(conf[:css_compressor_options] || {})
+    set_javascript_compressor(conf[:javascript_compressor])
+    set_package_assets(conf[:package_assets])
+    set_template_function(conf[:template_function])
+    set_template_namespace(conf[:template_namespace])
+    set_template_extension(conf[:template_extension])
+    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[:ram_packager] = nil
+    load_configuration(@config_path)
+  end
+
+  # Keep a global (thread-local) reference to a @Ram::Packager@, to avoid
+  # recomputing asset lists unnecessarily.
+  def self.packager
+    Thread.current[:ram_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 Ram, using the default options.
+  def self.package!(options={})
+    options = {
+      :config_path    => Ram::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`
+  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 = 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     = 'production'
+    @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
+
+  # Ram 0.5+ no longer supports separate template packages.
+  def self.check_for_deprecations
+    if @configuration[:templates]
+      raise DeprecationError, "Ram 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 = "Ram 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 'ram/dependencies'

data/lib/ram/command_line.rb

@@ -0,0 +1,84 @@
+require 'optparse'
+require File.expand_path(File.dirname(__FILE__) + '/../ram')
+
+module Ram
+
+  # 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: ram OPTIONS
+
+Run ram 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 @Ram::CommandLine@ runs from the contents of @ARGV@.
+    def initialize
+      parse_options
+      ensure_configuration_file
+      Ram.package!(@options)
+    end
+
+
+    private
+
+    # Make sure that we have a readable configuration file. The @ram@
+    # 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    => Ram::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 Ram version') do
+          puts "Ram version #{Ram::VERSION}"
+          exit
+        end
+      end
+      @option_parser.banner = BANNER
+      @option_parser.parse!(ARGV)
+    end
+
+  end
+
+end

data/lib/ram/compressor.rb

@@ -0,0 +1,253 @@
+module Ram
+
+  # Uses the YUI Compressor or Closure Compiler to compress JavaScript.
+  # Always uses YUI to compress CSS (Which means that Java must be installed.)
+  # Also knows how to create a concatenated JST file.
+  # If "embed_assets" is turned on, creates "mhtml" and "datauri" versions of
+  # all stylesheets, with all enabled assets inlined into the css.
+  class Compressor
+
+    # Mapping from extension to mime-type of all embeddable assets.
+    EMBED_MIME_TYPES = {
+      '.png'  => 'image/png',
+      '.jpg'  => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif'  => 'image/gif',
+      '.tif'  => 'image/tiff',
+      '.tiff' => 'image/tiff',
+      '.ttf'  => 'font/truetype',
+      '.otf'  => 'font/opentype',
+      '.woff' => 'font/woff'
+    }
+
+    # Font extensions for which we allow embedding:
+    EMBED_EXTS      = EMBED_MIME_TYPES.keys
+    EMBED_FONTS     = ['.ttf', '.otf', '.woff']
+
+    # (32k - padding) maximum length for data-uri assets (an IE8 limitation).
+    MAX_IMAGE_SIZE  = 32700
+
+    # CSS asset-embedding regexes for URL rewriting.
+    EMBED_DETECTOR  = /url\(['"]?([^\s)]+\.[a-z]+)(\?\d+)?['"]?\)/
+    EMBEDDABLE      = /[\A\/]embed\//
+    EMBED_REPLACER  = /url\(__EMBED__(.+?)(\?\d+)?\)/
+
+    # MHTML file constants.
+    MHTML_START     = "/*\r\nContent-Type: multipart/related; boundary=\"MHTML_MARK\"\r\n\r\n"
+    MHTML_SEPARATOR = "--MHTML_MARK\r\n"
+    MHTML_END       = "\r\n--MHTML_MARK--\r\n*/\r\n"
+
+    # JST file constants.
+    JST_START       = "(function(){"
+    JST_END         = "})();"
+
+    COMPRESSORS = {
+      :yui      => YUI::JavaScriptCompressor,
+      :closure  => Ram.compressors.include?(:closure)  ? Closure::Compiler : nil,
+      :uglifier => Ram.compressors.include?(:uglifier) ? Ram::Uglifier  : nil
+    }
+
+    DEFAULT_OPTIONS = {
+      :yui      => {:munge => true},
+      :closure  => {},
+      :uglifier => {:copyright => false}
+    }
+
+    # The css compressor is always the YUI Compressor. JS compression can be
+    # provided with YUI Compressor, Google Closure Compiler or UglifyJS.
+    def initialize
+      Ram.check_java_version
+      @css_compressor = YUI::CssCompressor.new(Ram.css_compressor_options || {})
+      flavor          = Ram.javascript_compressor || Ram::DEFAULT_COMPRESSOR
+      @options        = DEFAULT_OPTIONS[flavor].merge(Ram.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(Ram.template_extension_matcher)).empty?
+        js = concatenate(paths)
+      else
+        js = concatenate(paths - jst_paths) + compile_jst(jst_paths)
+      end
+      Ram.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 Ram.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   = Ram.template_namespace
+      paths       = paths.grep(Ram.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}'] = #{Ram.template_function}('#{contents}');"
+      end
+      compiler = Ram.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, ".#{Ram.template_extension}") unless base_path
+      path.gsub(/\A#{Regexp.escape(base_path)}\/(.*)\.#{Ram.template_extension}\Z/, '\1')
+    end
+
+    # In order to support embedded assets from relative paths, we need to
+    # expand the paths before contatenating the CSS together and losing the
+    # location of the original stylesheet path. Validate the assets while we're
+    # at it.
+    def concatenate_and_tag_assets(paths, variant=nil)
+      stylesheets = [paths].flatten.map do |css_path|
+        contents = read_binary_file(css_path)
+        contents.gsub(EMBED_DETECTOR) do |url|
+          ipath, cpath = Pathname.new($1), Pathname.new(File.expand_path(css_path))
+          is_url = URI.parse($1).absolute?
+          is_url ? url : "url(#{construct_asset_path(ipath, cpath, variant)})"
+        end
+      end
+      stylesheets.join("\n")
+    end
+
+    # Re-write all enabled asset URLs in a stylesheet with their corresponding
+    # Data-URI Base-64 encoded asset contents.
+    def with_data_uris(css)
+      css.gsub(EMBED_REPLACER) do |url|
+        "url(\"data:#{mime_type($1)};charset=utf-8;base64,#{encoded_contents($1)}\")"
+      end
+    end
+
+    # Re-write all enabled asset URLs in a stylesheet with the MHTML equivalent.
+    # The newlines ("\r\n") in the following method are critical. Without them
+    # your MHTML will look identical, but won't work.
+    def with_mhtml(css, asset_url)
+      paths, index = {}, 0
+      css = css.gsub(EMBED_REPLACER) do |url|
+        i = paths[$1] ||= "#{index += 1}-#{File.basename($1)}"
+        "url(mhtml:#{asset_url}!#{i})"
+      end
+      mhtml = paths.sort.map do |path, identifier|
+        mime, contents = mime_type(path), encoded_contents(path)
+        [MHTML_SEPARATOR, "Content-Location: #{identifier}\r\n", "Content-Type: #{mime}\r\n", "Content-Transfer-Encoding: base64\r\n\r\n", contents, "\r\n"]
+      end
+      [MHTML_START, mhtml, MHTML_END, css].flatten.join('')
+    end
+
+    # Return a rewritten asset URL for a new stylesheet -- the asset should
+    # be tagged for embedding if embeddable, and referenced at the correct level
+    # if relative.
+    def construct_asset_path(asset_path, css_path, variant)
+      public_path = absolute_path(asset_path, css_path)
+      return "__EMBED__#{public_path}" if embeddable?(public_path, variant)
+      source = asset_path.absolute? ? asset_path.to_s : relative_path(public_path)
+      rewrite_asset_path(source, public_path)
+    end
+
+    # Get the site-absolute public path for an asset file path that may or may
+    # not be relative, given the path of the stylesheet that contains it.
+    def absolute_path(asset_pathname, css_pathname)
+      (asset_pathname.absolute? ?
+        Pathname.new(File.join(Ram.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(Ram.public_root, ''))
+    end
+
+    # Similar to the AssetTagHelper's method of the same name, this will
+    # append the ASSET_ID cache-buster to URLs, if it's defined.
+    def rewrite_asset_path(path, file_path)
+      asset_id = get_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 get_asset_id(path)
+      asset_id = ENV["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/ram/dependencies.rb

@@ -0,0 +1,35 @@
+# Standard Library Dependencies:
+require 'uri'
+require 'erb'
+require 'zlib'
+require 'yaml'
+require 'base64'
+require 'pathname'
+require 'fileutils'
+
+# Include YUI as the default
+require 'yui/compressor'
+
+# Try Closure.
+begin
+  require 'closure-compiler'
+rescue LoadError
+  Ram.compressors.delete :closure
+end
+
+# Try Uglifier.
+begin
+  require 'uglifier'
+rescue LoadError
+  Ram.compressors.delete :uglifier
+end
+
+# Load initial configuration before the rest of Ram.
+Ram.load_configuration(Ram::DEFAULT_CONFIG_PATH, true)
+
+# Ram Core:
+require 'ram/uglifier' if Ram.compressors.include? :uglifier
+require 'ram/compressor'
+require 'ram/packager'
+
+# TODO: See if the helper might be useful in a nanoc environment...

data/lib/ram/helper.rb

@@ -0,0 +1,87 @@
+# module Ram
+# 
+#   # The Ram::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 || !Ram.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)
+#       html_safe packages.map {|pack|
+#         should_package? ? Ram.asset_url(pack, :js) : Ram.packager.individual_urls(pack.to_sym, :js)
+#       }.flatten.map {|pack|
+#         javascript_include_tag pack
+#       }.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, "Ram 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?
+#       Ram.package_assets && !(Ram.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| Ram.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| Ram.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| Ram.asset_url(p, :css, :datauri) }
+#       ie_tags = Ram.mhtml_enabled ?
+#                 tags_with_options(packages, options) {|p| Ram.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 Ram asset helpers in all views, a-la ApplicationHelper.
+# ::ActionView::Base.send(:include, Ram::Helper)

data/lib/ram/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/ram/packager.rb

@@ -0,0 +1,173 @@
+module Ram
+
+  # The Ram::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
+    # Ram.configuration. When assets.yml is being changed on the fly,
+    # create a new Packager.
+    def initialize
+      # The difference between a path and an asset URL is "public".
+      @path_diff   = Ram.public_root.sub(ASSET_ROOT, '')
+      @path_to_url = /\A#{Regexp.escape(ASSET_ROOT)}(\/?#{Regexp.escape(@path_diff)})?/
+      
+      @compressor     = Compressor.new
+      @force          = false
+      @package_names  = nil
+      @config = {
+        :css => (Ram.configuration[:stylesheets] || {}),
+        :js  => (Ram.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(Ram.public_root, Ram.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 Ram.embed_assets
+          cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
+          if Ram.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}#{Ram.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, "Ram 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, Ram.filename(package, extension, suffix))
+      File.open(file_name, 'wb+') {|f| f.write(contents) }
+      if Ram.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
+      Ram.warn("No assets match '#{glob}'") if paths.empty?
+      paths
+    end
+    
+    # Get the latest mtime of a list of files (plus the config path).
+    def latest_mtime(paths)
+      paths += [Ram.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(Ram.config_path)
+      return names if @force
+      return names.select do |name|
+        pack        = package_for(name, extension)
+        cached      = [Ram.filename(name, extension)]
+        cached.push Ram.filename(name, extension, :datauri) if Ram.embed_assets
+        cached.push Ram.filename(name, extension, :mhtml) if Ram.mhtml_enabled
+        cached.map! {|file| File.join(output_dir, file) }
+        if cached.any? {|file| !File.exists?(file) }
+          true
+        else
+          since = cached.map {|file| File.mtime(file) }.min
+          config_mtime > since || pack[:paths].any? {|src| File.mtime(src) > since }
+        end
+      end
+    end
+
+    # Compiles the list of assets that goes into each package. Runs an
+    # ordered list of Dir.globs, taking the merged unique result.
+    # If there are JST files in this package we need to add an extra
+    # path for when package_assets is off (e.g. in a dev environment).
+    # This package (e.g. /assets/package-name.jst) will never exist as
+    # an actual file but will be dynamically generated by Ram on
+    # every request.
+    def create_packages(config)
+      packages = {}
+      return packages if !config
+      config.each do |name, globs|
+        globs                  ||= []
+        packages[name]         = {}
+        paths                  = globs.flatten.uniq.map {|glob| glob_files(glob) }.flatten.uniq
+        packages[name][:paths] = paths
+        if !paths.grep(Ram.template_extension_matcher).empty?
+          packages[name][:urls] = paths.grep(JS_EXTENSION).map {|path| path.sub(@path_to_url, '') }
+          packages[name][:urls] += [Ram.asset_url(name, Ram.template_extension)]
+        else
+          packages[name][:urls] = paths.map {|path| path.sub(@path_to_url, '') }
+        end
+      end
+      packages
+    end
+
+    # Raise a PackageNotFound exception for missing packages...
+    def not_found(package, extension)
+      raise PackageNotFound, "assets.yml does not contain a \"#{package}\" #{extension.to_s.upcase} package"
+    end
+
+  end
+
+end

data/lib/ram/uglifier.rb

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

data/ram.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name      = 'ram'
+  s.version   = '0.0.1'         # Keep version in sync with ram.rb
+  s.date      = '2011-10-25'
+
+  s.homepage    = "http://fleetventures.com/"
+  s.summary     = "Asset Packaging"
+  s.description = <<-EOS
+    Ram is an asset packaging library for any type of web project.  It was 
+    originalyl adapted from the excellent Jammit gem, but without any Rails
+    dependencies or tie ins.   This provides 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           = ['David Richards']
+  s.email             = 'david@fleetventures.com'
+  s.rubyforge_project = 'ram'
+
+  s.require_paths     = ['lib']
+  s.executables       = ['ram']
+
+  s.extra_rdoc_files  = ['README.md']
+  s.rdoc_options      << '--title'    << 'Ram' <<
+                         '--exclude'  << 'test' <<
+                         '--main'     << 'README.md' <<
+                         '--all'
+
+  s.add_dependency 'yui-compressor',    ['>= 0.9.3']
+
+  s.files = Dir['lib/**/*', 'bin/*', 'ram.gemspec', 'LICENSE', 'README.md']
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: ram
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Richards
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yui-compressor
+  requirement: &2153929620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153929620
+description: ! "    Ram is an asset packaging library for any type of web project.
+  \ It was \n    originalyl adapted from the excellent Jammit gem, but without any
+  Rails\n    dependencies or tie ins.   This provides both the CSS and JavaScript
+  \n    concatenation and compression that you'd expect, as well as YUI Compressor
+  \n    and Closure Compiler compatibility, ahead-of-time gzipping, built-in \n    JavaScript
+  template support, and optional Data-URI / MHTML image embedding.\n"
+email: david@fleetventures.com
+executables:
+- ram
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/ram/command_line.rb
+- lib/ram/compressor.rb
+- lib/ram/dependencies.rb
+- lib/ram/helper.rb
+- lib/ram/jst.js
+- lib/ram/packager.rb
+- lib/ram/uglifier.rb
+- lib/ram.rb
+- bin/ram
+- ram.gemspec
+- LICENSE
+- README.md
+homepage: http://fleetventures.com/
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- Ram
+- --exclude
+- test
+- --main
+- README.md
+- --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: ram
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Asset Packaging
+test_files: []
+has_rdoc: