jammit 0.3.3 → 0.4.0

data/jammit.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name      = 'jammit'
-  s.version   = '0.3.3'         # Keep version in sync with jammit.rb
-  s.date      = '2009-1-5'
+  s.version   = '0.4.0'         # Keep version in sync with jammit.rb
+  s.date      = '2009-1-26'
 
   s.homepage    = "http://documentcloud.github.com/jammit/"
   s.summary     = "Industrial Strength Asset Packaging for Rails"

data/lib/jammit.rb

@@ -4,11 +4,11 @@ $LOAD_PATH.push File.expand_path(File.dirname(__FILE__))
 # to all of the configuration options.
 module Jammit
 
-  VERSION               = "0.3.3"
+  VERSION               = "0.4.0"
 
   ROOT                  = File.expand_path(File.dirname(__FILE__) + '/..')
 
-  ASSET_ROOT            = File.expand_path(defined?(RAILS_ROOT) ? RAILS_ROOT : ".")
+  ASSET_ROOT            = File.expand_path(defined?(Rails) ? Rails.root : ".") unless defined?(ASSET_ROOT)
 
   PUBLIC_ROOT           = "#{ASSET_ROOT}/public"
 
@@ -20,10 +20,16 @@ module Jammit
 
   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_EXT                = /\.js\Z/
+  JST_EXT               = /\.jst\Z/
+
   # Jammit raises a @PackageNotFound@ exception when a non-existent package is
   # requested by a browser -- rendering a 404.
   class PackageNotFound < NameError; end
@@ -37,7 +43,7 @@ module Jammit
   class OutputNotWritable < StandardError; end
 
   class << self
-    attr_reader :configuration, :template_function, :embed_images, :package_path,
+    attr_reader :configuration, :template_function, :template_namespace, :embed_assets, :package_path,
                 :package_assets, :compress_assets, :mhtml_enabled, :include_jst_script,
                 :javascript_compressor, :compressor_options, :css_compressor_options
   end
@@ -48,19 +54,21 @@ module Jammit
 
   # Load the complete asset configuration from the specified @config_path@.
   def self.load_configuration(config_path)
-    conf = config_path && File.exists?(config_path) && YAML.load_file(config_path)
-    raise ConfigurationNotFound, "could not find the \"#{config_path}\" configuration file" unless conf
+    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_images           = conf[:embed_images]
+    @embed_assets           = conf[:embed_assets] || conf[:embed_images]
     @compress_assets        = !(conf[:compress_assets] == false)
-    @mhtml_enabled          = @embed_images && @embed_images != "datauri"
+    @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])
     check_java_version
     self
   end
@@ -113,6 +121,11 @@ module Jammit
     @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
+
   # The YUI Compressor requires Java > 1.4, and Closure requires Java > 1.6.
   def self.check_java_version
     java = @compressor_options[:java] || 'java'

data/lib/jammit/command_line.rb

@@ -16,7 +16,7 @@ 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_images", and you wish to precompile the
+If you're using "embed_assets", and you wish to precompile the
 MHTML stylesheet variants, you must specify the "base-url".
 
 Options:

data/lib/jammit/compressor.rb

@@ -3,24 +3,33 @@ 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_images" is turned on, creates "mhtml" and "datauri" versions of
-  # all stylesheets, with all enabled images inlined into the css.
+  # 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 images.
-    IMAGE_MIME_TYPES = {
+    # 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'
+      '.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']
 
-    IMAGE_DETECTOR  = /url\(['"]?([^\s)]+\.(png|jpg|jpeg|gif|tif|tiff))['"]?\)/
-    IMAGE_EMBED     = /[\A\/]embed\//
-    IMAGE_REPLACER  = /url\(__EMBED__([^\s)]+)\)/
+    # Maximum size for embeddable images (an IE8 limitation).
+    MAX_IMAGE_SIZE  = 32.kilobytes
+
+    # 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"
@@ -28,7 +37,7 @@ module Jammit
     MHTML_END       = "*/\r\n"
 
     # JST file constants.
-    JST_START       = "(function(){window.JST = window.JST || {};"
+    JST_START       = "(function(){"
     JST_END         = "})();"
 
     COMPRESSORS = {
@@ -45,24 +54,28 @@ module Jammit
     # 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
-      @options        = DEFAULT_OPTIONS[flavor].merge(Jammit.compressor_options)
+      @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).
+    # YUI Compressor (with munging enabled). JST can optionally be included.
     def compress_js(paths)
-      js = concatenate(paths)
+      if (jst_paths = paths.grep(JST_EXT)).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 images.
+    # referenced assets.
     def compress_css(paths, variant=nil, asset_url=nil)
-      css = concatenate_and_tag_images(paths, variant)
+      css = concatenate_and_tag_assets(paths, variant)
       css = @css_compressor.compress(css) if Jammit.compress_assets
       case variant
       when nil      then return css
@@ -73,52 +86,54 @@ module Jammit
     end
 
     # Compiles a single JST file by writing out a javascript that adds
-    # template properties to a top-level "window.JST" object. Adds a
+    # 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)
-      compiled = paths.map do |path|
+      namespace = Jammit.template_namespace
+      compiled = paths.grep(JST_EXT).map do |path|
         template_name = File.basename(path, File.extname(path))
         contents      = File.read(path).gsub(/\n/, '').gsub("'", '\\\\\'')
-        "window.JST.#{template_name} = #{Jammit.template_function}('#{contents}');"
+        "#{namespace}.#{template_name} = #{Jammit.template_function}('#{contents}');"
       end
       compiler = Jammit.include_jst_script ? File.read(DEFAULT_JST_SCRIPT) : '';
-      [JST_START, compiler, compiled, JST_END].flatten.join("\n")
+      setup_namespace = "#{namespace} = #{namespace} || {};"
+      [JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
     end
 
 
     private
 
-    # In order to support embedded images from relative paths, we need to
+    # 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 images while we're
+    # location of the original stylesheet path. Validate the assets while we're
     # at it.
-    def concatenate_and_tag_images(paths, variant=nil)
+    def concatenate_and_tag_assets(paths, variant=nil)
       stylesheets = [paths].flatten.map do |css_path|
-        File.read(css_path).gsub(IMAGE_DETECTOR) do |url|
+        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(#{rewrite_image_path(ipath, cpath, !!variant)})"
+          is_url ? url : "url(#{rewrite_asset_path(ipath, cpath, variant)})"
         end
       end
       stylesheets.join("\n")
     end
 
-    # Re-write all enabled image URLs in a stylesheet with their corresponding
-    # Data-URI Base-64 encoded image contents.
+    # 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(IMAGE_REPLACER) do |url|
-        "url(\"data:#{mime_type($1)};base64,#{encoded_contents($1)}\")"
+      css.gsub(EMBED_REPLACER) do |url|
+        "url(\"data:#{mime_type($1)};charset=utf-8;base64,#{encoded_contents($1)}\")"
       end
     end
 
-    # Re-write all enabled image URLs in a stylesheet with the MHTML equivalent.
+    # 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(IMAGE_REPLACER) do |url|
+      css = css.gsub(EMBED_REPLACER) do |url|
         i = paths[$1] ||= "#{index += 1}-#{File.basename($1)}"
         "url(mhtml:#{asset_url}!#{i})"
       end
@@ -129,45 +144,51 @@ module Jammit
       [MHTML_START, mhtml, MHTML_END, css].flatten.join('')
     end
 
-    # Return a rewritten image URL for a new stylesheet -- the image should
+    # 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 rewrite_image_path(image_path, css_path, embed=false)
-      public_path = absolute_path(image_path, css_path)
-      return "__EMBED__#{public_path}" if embed && embeddable?(public_path)
-      image_path.absolute? ? image_path.to_s : relative_path(public_path)
+    def rewrite_asset_path(asset_path, css_path, variant)
+      public_path = absolute_path(asset_path, css_path)
+      return "__EMBED__#{public_path}" if embeddable?(public_path, variant)
+      asset_path.absolute? ? asset_path.to_s : relative_path(public_path)
     end
 
-    # Get the site-absolute public path for an image file path that may or may
+    # 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(image_pathname, css_pathname)
-      (image_pathname.absolute? ?
-        Pathname.new(File.join(PUBLIC_ROOT, image_pathname)) :
-        css_pathname.dirname + image_pathname).cleanpath
+    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 images that are referenced by relative paths, and are *not* being
+    # 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
 
-    # An image is valid for embedding if it exists, is less than 32K, and is
+    # 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 images that large in any case.
-    def embeddable?(image_path)
-      image_path.to_s.match(IMAGE_EMBED) && image_path.exist? && image_path.size < 32.kilobytes
+    # 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 image on a single line.
-    def encoded_contents(image_path)
-      Base64.encode64(File.read(image_path)).gsub(/\n/, '')
+    # Return the Base64-encoded contents of an asset on a single line.
+    def encoded_contents(asset_path)
+      Base64.encode64(File.read(asset_path)).gsub(/\n/, '')
     end
 
-    # Grab the mime-type of an image, by filename.
-    def mime_type(image_path)
-      IMAGE_MIME_TYPES[File.extname(image_path)]
+    # 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.

data/lib/jammit/controller.rb

@@ -63,9 +63,9 @@ module Jammit
       pack       = params[:package]
       @extension = params[:extension].to_sym
       raise PackageNotFound unless VALID_FORMATS.include?(@extension)
-      if Jammit.embed_images
+      if Jammit.embed_assets
         suffix_match = pack.match(SUFFIX_STRIPPER)
-        @variant = Jammit.embed_images && suffix_match && suffix_match[1].to_sym
+        @variant = Jammit.embed_assets && suffix_match && suffix_match[1].to_sym
         pack.sub!(SUFFIX_STRIPPER, '')
       end
       @package = pack.to_sym

data/lib/jammit/dependencies.rb

@@ -1,5 +1,6 @@
 # Standard Library Dependencies:
 require 'uri'
+require 'erb'
 require 'zlib'
 require 'base64'
 require 'pathname'

data/lib/jammit/helper.rb

@@ -11,13 +11,14 @@ module Jammit
     MHTML_START    = "<!--[if lte IE 7]>"
     MHTML_END      = "<![endif]-->"
 
-    # If embed_images is turned on, writes out links to the Data-URI and MHTML
+    # 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
-      return packaged_stylesheets(packages, options) if options.delete(:embed_images) == false || !Jammit.embed_images
+      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
 

data/lib/jammit/jst.js

@@ -1 +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, " ").split("<%").join("\t").replace(/((^|%>)[^\t]*)'/g, "$1\r").replace(/\t=(.*?)%>/g, "',$1,'").split("\t").join("');").split("%>").join("p.push('").split("\r").join("\\'")+"');}return p.join('');"); return fn;};
+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

@@ -42,7 +42,7 @@ module Jammit
       cacheable(:jst, output_dir).each {|p| cache(p, 'jst', pack_templates(p),  output_dir) }
       cacheable(:css, output_dir).each do |p|
         cache(p, 'css', pack_stylesheets(p), output_dir)
-        if Jammit.embed_images
+        if Jammit.embed_assets
           cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
           if Jammit.mhtml_enabled && base_url
             mtime = Time.now
@@ -93,6 +93,7 @@ module Jammit
     # package has gone missing.
     def package_for(package, extension)
       pack = @packages[extension] && @packages[extension][package]
+      pack ||= @packages[:js] && @packages[:js][package] if extension == :jst
       pack || not_found(package, extension)
     end
 
@@ -126,7 +127,12 @@ module Jammit
         packages[name]         = {}
         paths                  = globs.map {|glob| glob_files(glob) }.flatten.uniq
         packages[name][:paths] = paths
-        packages[name][:urls]  = paths.map {|path| path.sub(PATH_TO_URL, '') }
+        if !paths.grep(JS_EXT).empty? && !paths.grep(JST_EXT).empty?
+          packages[name][:urls] = paths.grep(JS_EXT).map {|path| path.sub(PATH_TO_URL, '') }
+          packages[name][:urls] += [Jammit.asset_url(name, :jst)]
+        else
+          packages[name][:urls] = paths.map {|path| path.sub(PATH_TO_URL, '') }
+        end
       end
       packages
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jammit
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors: 
 - Jeremy Ashkenas
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-05 00:00:00 -05:00
+date: 2009-01-26 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency