agibralter-jammit 0.5.0

Sign up to get free protection for your applications and to get access to all the features.
data/LICENSE ADDED
@@ -0,0 +1,22 @@
1
+ Copyright (c) 2009 Jeremy Ashkenas, DocumentCloud
2
+
3
+ Permission is hereby granted, free of charge, to any person
4
+ obtaining a copy of this software and associated documentation
5
+ files (the "Software"), to deal in the Software without
6
+ restriction, including without limitation the rights to use,
7
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
8
+ copies of the Software, and to permit persons to whom the
9
+ Software is furnished to do so, subject to the following
10
+ conditions:
11
+
12
+ The above copyright notice and this permission notice shall be
13
+ included in all copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22
+ OTHER DEALINGS IN THE SOFTWARE.
data/README ADDED
@@ -0,0 +1,24 @@
1
+ ==
2
+ _ _ __ __ __ __ ___ _____
3
+ _ | |/_\ | \/ | \/ |_ _|_ _|
4
+ | || / _ \| |\/| | |\/| || | | |
5
+ \__/_/ \_\_| |_|_| |_|___| |_|
6
+
7
+
8
+ Jammit is an industrial strength asset packaging library for Rails,
9
+ providing both the CSS and JavaScript concatenation and compression
10
+ that you'd expect, as well as ahead-of-time gzipping, built-in JavaScript
11
+ template support, and optional Data-URI / MHTML image embedding.
12
+
13
+ Installation:
14
+ gem install jammit
15
+
16
+ For documentation, usage, and examples, see:
17
+ http://documentcloud.github.com/jammit/
18
+
19
+ To suggest a feature or report a bug:
20
+ http://github.com/documentcloud/jammit/issues/
21
+
22
+ For internal source docs, see:
23
+ http://documentcloud.github.com/jammit/doc/
24
+
@@ -0,0 +1,5 @@
1
+ #!/usr/bin/env ruby -rrubygems
2
+
3
+ require "#{File.dirname(__FILE__)}/../lib/jammit/command_line.rb"
4
+
5
+ Jammit::CommandLine.new
@@ -0,0 +1,35 @@
1
+ Gem::Specification.new do |s|
2
+ s.name = 'agibralter-jammit'
3
+ s.version = '0.5.0' # Keep version in sync with jammit.rb
4
+ s.date = '2010-04-30'
5
+
6
+ s.homepage = "http://documentcloud.github.com/jammit/"
7
+ s.summary = "Industrial Strength Asset Packaging for Rails"
8
+ s.description = <<-EOS
9
+ Jammit is an industrial strength asset packaging library for Rails,
10
+ providing both the CSS and JavaScript concatenation and compression that
11
+ you'd expect, as well as YUI Compressor and Closure Compiler compatibility,
12
+ ahead-of-time gzipping, built-in JavaScript template support, and optional
13
+ Data-URI / MHTML image embedding.
14
+ EOS
15
+
16
+ s.authors = ['Jeremy Ashkenas']
17
+ s.email = 'jeremy@documentcloud.org'
18
+ s.rubyforge_project = 'jammit'
19
+
20
+ s.require_paths = ['lib']
21
+ s.executables = ['jammit']
22
+
23
+ s.has_rdoc = true
24
+ s.extra_rdoc_files = ['README']
25
+ s.rdoc_options << '--title' << 'Jammit' <<
26
+ '--exclude' << 'test' <<
27
+ '--main' << 'README' <<
28
+ '--all'
29
+
30
+ s.add_dependency 'rails', ['>= 2.0.0']
31
+ s.add_dependency 'yui-compressor', ['>= 0.9.1']
32
+ s.add_dependency 'closure-compiler', ['>= 0.1.0']
33
+
34
+ s.files = Dir['lib/**/*', 'bin/*', 'jammit.gemspec', 'LICENSE', 'README']
35
+ end
@@ -0,0 +1,183 @@
1
+ $LOAD_PATH.push File.expand_path(File.dirname(__FILE__))
2
+
3
+ # @Jammit@ is the central namespace for all Jammit classes, and provides access
4
+ # to all of the configuration options.
5
+ module Jammit
6
+
7
+ VERSION = "0.5.0"
8
+
9
+ ROOT = File.expand_path(File.dirname(__FILE__) + '/..')
10
+
11
+ ASSET_ROOT = File.expand_path(defined?(Rails) ? Rails.root : ".") unless defined?(ASSET_ROOT)
12
+
13
+ PUBLIC_ROOT = defined?(Rails) ? Rails.public_path : File.join(ASSET_ROOT, 'public')
14
+
15
+ DEFAULT_CONFIG_PATH = File.join(ASSET_ROOT, 'config', 'assets.yml')
16
+
17
+ DEFAULT_PACKAGE_PATH = "assets"
18
+
19
+ DEFAULT_JST_SCRIPT = File.join(ROOT, 'lib/jammit/jst.js')
20
+
21
+ DEFAULT_JST_COMPILER = "template"
22
+
23
+ DEFAULT_JST_NAMESPACE = "window.JST"
24
+
25
+ AVAILABLE_COMPRESSORS = [:yui, :closure]
26
+
27
+ DEFAULT_COMPRESSOR = :yui
28
+
29
+ # Extension matchers for JavaScript and JST, which need to be disambiguated.
30
+ JS_EXTENSION = /\.js\Z/
31
+ DEFAULT_JST_EXTENSION = "jst"
32
+
33
+ # Jammit raises a @PackageNotFound@ exception when a non-existent package is
34
+ # requested by a browser -- rendering a 404.
35
+ class PackageNotFound < NameError; end
36
+
37
+ # Jammit raises a ConfigurationNotFound exception when you try to load the
38
+ # configuration of an assets.yml file that doesn't exist.
39
+ class ConfigurationNotFound < NameError; end
40
+
41
+ # Jammit raises an OutputNotWritable exception if the output directory for
42
+ # cached packages is locked.
43
+ class OutputNotWritable < StandardError; end
44
+
45
+ # Jammit raises a DeprecationError if you try to use an outdated feature.
46
+ class DeprecationError < StandardError; end
47
+
48
+ class << self
49
+ attr_reader :configuration, :template_function, :template_namespace,
50
+ :embed_assets, :package_assets, :compress_assets, :gzip_assets,
51
+ :package_path, :mhtml_enabled, :include_jst_script,
52
+ :javascript_compressor, :compressor_options, :css_compressor_options,
53
+ :jst_extension, :jst_extension_regexp, :template_base_path
54
+ end
55
+
56
+ # The minimal required configuration.
57
+ @configuration = {}
58
+ @package_path = DEFAULT_PACKAGE_PATH
59
+
60
+ # Load the complete asset configuration from the specified @config_path@.
61
+ def self.load_configuration(config_path)
62
+ exists = config_path && File.exists?(config_path)
63
+ raise ConfigurationNotFound, "could not find the \"#{config_path}\" configuration file" unless exists
64
+ conf = YAML.load(ERB.new(File.read(config_path)).result)
65
+ @config_path = config_path
66
+ @configuration = conf = conf.symbolize_keys
67
+ @package_path = conf[:package_path] || DEFAULT_PACKAGE_PATH
68
+ @embed_assets = conf[:embed_assets] || conf[:embed_images]
69
+ @compress_assets = !(conf[:compress_assets] == false)
70
+ @gzip_assets = !(conf[:gzip_assets] == false)
71
+ @mhtml_enabled = @embed_assets && @embed_assets != "datauri"
72
+ @compressor_options = (conf[:compressor_options] || {}).symbolize_keys
73
+ @css_compressor_options = (conf[:css_compressor_options] || {}).symbolize_keys
74
+ set_javascript_compressor(conf[:javascript_compressor])
75
+ set_package_assets(conf[:package_assets])
76
+ set_template_function(conf[:template_function])
77
+ set_template_namespace(conf[:template_namespace])
78
+ set_template_extension(conf[:template_extension])
79
+ set_template_base_path(conf[:template_base_path])
80
+ check_java_version
81
+ check_for_deprecations
82
+ self
83
+ end
84
+
85
+ # Force a reload by resetting the Packager and reloading the configuration.
86
+ # In development, this will be called as a before_filter before every request.
87
+ def self.reload!
88
+ Thread.current[:jammit_packager] = nil
89
+ load_configuration(@config_path)
90
+ end
91
+
92
+ # Keep a global (thread-local) reference to a @Jammit::Packager@, to avoid
93
+ # recomputing asset lists unnecessarily.
94
+ def self.packager
95
+ Thread.current[:jammit_packager] ||= Packager.new
96
+ end
97
+
98
+ # Generate the base filename for a version of a given package.
99
+ def self.filename(package, extension, suffix=nil)
100
+ suffix_part = suffix ? "-#{suffix}" : ''
101
+ "#{package}#{suffix_part}.#{extension}"
102
+ end
103
+
104
+ # Generates the server-absolute URL to an asset package.
105
+ def self.asset_url(package, extension, suffix=nil, mtime=nil)
106
+ timestamp = mtime ? "?#{mtime.to_i}" : ''
107
+ "/#{package_path}/#{filename(package, extension, suffix)}#{timestamp}"
108
+ end
109
+
110
+
111
+ private
112
+
113
+ # Ensure that the JavaScript compressor is a valid choice.
114
+ def self.set_javascript_compressor(value)
115
+ value = value && value.to_sym
116
+ @javascript_compressor = AVAILABLE_COMPRESSORS.include?(value) ? value : DEFAULT_COMPRESSOR
117
+ end
118
+
119
+ # Turn asset packaging on or off, depending on configuration and environment.
120
+ def self.set_package_assets(value)
121
+ package_env = !defined?(Rails) || !Rails.env.development?
122
+ @package_assets = value == true || value.nil? ? package_env :
123
+ value == 'always' ? true : false
124
+ end
125
+
126
+ # Assign the JST template function, unless explicitly turned off.
127
+ def self.set_template_function(value)
128
+ @template_function = value == true || value.nil? ? DEFAULT_JST_COMPILER :
129
+ value == false ? '' : value
130
+ @include_jst_script = @template_function == DEFAULT_JST_COMPILER
131
+ end
132
+
133
+ # Set the root JS object in which to stash all compiled JST.
134
+ def self.set_template_namespace(value)
135
+ @template_namespace = value == true || value.nil? ? DEFAULT_JST_NAMESPACE : value.to_s
136
+ end
137
+
138
+ # Set the extension for JS templates.
139
+ def self.set_template_extension(value)
140
+ @jst_extension = (value == true || value.nil? ? DEFAULT_JST_EXTENSION : value.to_s).gsub(/\A\.?(.*)\Z/, '.\1')
141
+ @jst_extension_regexp = /#{Regexp.escape(@jst_extension)}\Z/
142
+ end
143
+
144
+ def self.set_template_base_path(value)
145
+ if (@template_base_path = value == true || value.nil? ? nil : Pathname.new(value.to_s)) && !@template_base_path.absolute?
146
+ @template_base_path = Pathname.new(ASSET_ROOT) + @template_base_path
147
+ end
148
+ end
149
+
150
+ # The YUI Compressor requires Java > 1.4, and Closure requires Java > 1.6.
151
+ def self.check_java_version
152
+ return true if @checked_java_version
153
+ java = @compressor_options[:java] || 'java'
154
+ @css_compressor_options[:java] ||= java if @compressor_options[:java]
155
+ version = (`#{java} -version 2>&1`)[/\d+\.\d+/]
156
+ disable_compression if !version ||
157
+ (@javascript_compressor == :closure && version < '1.6') ||
158
+ (@javascript_compressor == :yui && version < '1.4')
159
+ @checked_java_version = true
160
+ end
161
+
162
+ # If we don't have a working Java VM, then disable asset compression and
163
+ # complain loudly.
164
+ def self.disable_compression
165
+ @compress_assets = false
166
+ warn("Asset compression disabled -- Java unavailable.")
167
+ end
168
+
169
+ # Jammit 0.5+ no longer supports separate template packages.
170
+ def self.check_for_deprecations
171
+ 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]
172
+ end
173
+
174
+ def self.warn(message)
175
+ message = "Jammit Warning: #{message}"
176
+ @logger ||= (defined?(Rails) && Rails.logger ? Rails.logger :
177
+ defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil)
178
+ @logger ? @logger.warn(message) : STDERR.puts(message)
179
+ end
180
+
181
+ end
182
+
183
+ require 'jammit/dependencies'
@@ -0,0 +1,79 @@
1
+ require 'optparse'
2
+ require File.expand_path(File.dirname(__FILE__) + '/../jammit')
3
+
4
+ module Jammit
5
+
6
+ # The @CommandLine@ is able to compress, pre-package, and pre-gzip all the
7
+ # assets specified in the configuration file, in order to avoid an initial
8
+ # round of slow requests after a fresh deployment.
9
+ class CommandLine
10
+
11
+ BANNER = <<-EOS
12
+
13
+ Usage: jammit OPTIONS
14
+
15
+ Run jammit inside a Rails application to compresses all JS, CSS,
16
+ and JST according to config/assets.yml, saving the packaged
17
+ files and corresponding gzipped versions.
18
+
19
+ If you're using "embed_assets", and you wish to precompile the
20
+ MHTML stylesheet variants, you must specify the "base-url".
21
+
22
+ Options:
23
+ EOS
24
+
25
+ # The @Jammit::CommandLine@ runs from the contents of @ARGV@.
26
+ def initialize
27
+ parse_options
28
+ ensure_configuration_file
29
+ Jammit.load_configuration(@options[:config_path])
30
+ Jammit.packager.force = @options[:force]
31
+ Jammit.packager.precache_all(@options[:output_folder], @options[:base_url])
32
+ end
33
+
34
+
35
+ private
36
+
37
+ # Make sure that we have a readable configuration file. The @jammit@
38
+ # command can't run without one.
39
+ def ensure_configuration_file
40
+ config = @options[:config_path]
41
+ return true if File.exists?(config) && File.readable?(config)
42
+ puts "Could not find the asset configuration file \"#{config}\""
43
+ exit(1)
44
+ end
45
+
46
+ # Uses @OptionParser@ to grab the options: *--output*, *--config*, and
47
+ # *--base-url*...
48
+ def parse_options
49
+ @options = {
50
+ :config_path => Jammit::DEFAULT_CONFIG_PATH,
51
+ :output_folder => nil,
52
+ :base_url => nil,
53
+ :force => false
54
+ }
55
+ @option_parser = OptionParser.new do |opts|
56
+ opts.on('-o', '--output PATH', 'output folder for packages (default: "public/assets")') do |output_folder|
57
+ @options[:output_folder] = output_folder
58
+ end
59
+ opts.on('-c', '--config PATH', 'path to assets.yml (default: "config/assets.yml")') do |config_path|
60
+ @options[:config_path] = config_path
61
+ end
62
+ opts.on('-u', '--base-url URL', 'base URL for MHTML (ex: "http://example.com")') do |base_url|
63
+ @options[:base_url] = base_url
64
+ end
65
+ opts.on('-f', '--force', 'force a rebuild of all assets') do |force|
66
+ @options[:force] = force
67
+ end
68
+ opts.on_tail('-v', '--version', 'display Jammit version') do
69
+ puts "Jammit version #{Jammit::VERSION}"
70
+ exit
71
+ end
72
+ end
73
+ @option_parser.banner = BANNER
74
+ @option_parser.parse!(ARGV)
75
+ end
76
+
77
+ end
78
+
79
+ end
@@ -0,0 +1,222 @@
1
+ module Jammit
2
+
3
+ # Uses the YUI Compressor or Closure Compiler to compress JavaScript.
4
+ # Always uses YUI to compress CSS (Which means that Java must be installed.)
5
+ # Also knows how to create a concatenated JST file.
6
+ # If "embed_assets" is turned on, creates "mhtml" and "datauri" versions of
7
+ # all stylesheets, with all enabled assets inlined into the css.
8
+ class Compressor
9
+
10
+ # Mapping from extension to mime-type of all embeddable assets.
11
+ EMBED_MIME_TYPES = {
12
+ '.png' => 'image/png',
13
+ '.jpg' => 'image/jpeg',
14
+ '.jpeg' => 'image/jpeg',
15
+ '.gif' => 'image/gif',
16
+ '.tif' => 'image/tiff',
17
+ '.tiff' => 'image/tiff',
18
+ '.ttf' => 'font/truetype',
19
+ '.otf' => 'font/opentype'
20
+ }
21
+
22
+ # Font extensions for which we allow embedding:
23
+ EMBED_EXTS = EMBED_MIME_TYPES.keys
24
+ EMBED_FONTS = ['.ttf', '.otf']
25
+
26
+ # 32k maximum size for embeddable images (an IE8 limitation).
27
+ MAX_IMAGE_SIZE = 32768
28
+
29
+ # CSS asset-embedding regexes for URL rewriting.
30
+ EMBED_DETECTOR = /url\(['"]?([^\s)]+\.[a-z]+)(\?\d+)?['"]?\)/
31
+ EMBEDDABLE = /[\A\/]embed\//
32
+ EMBED_REPLACER = /url\(__EMBED__([^\s)]+)(\?\d+)?\)/
33
+
34
+ # MHTML file constants.
35
+ MHTML_START = "/*\r\nContent-Type: multipart/related; boundary=\"JAMMIT_MHTML_SEPARATOR\"\r\n\r\n"
36
+ MHTML_SEPARATOR = "--JAMMIT_MHTML_SEPARATOR\r\n"
37
+ MHTML_END = "*/\r\n"
38
+
39
+ # JST file constants.
40
+ JST_START = "(function(){"
41
+ JST_END = "})();"
42
+
43
+ COMPRESSORS = {
44
+ :yui => YUI::JavaScriptCompressor,
45
+ :closure => Closure::Compiler
46
+ }
47
+
48
+ DEFAULT_OPTIONS = {
49
+ :yui => {:munge => true},
50
+ :closure => {}
51
+ }
52
+
53
+ # Creating a compressor initializes the internal YUI Compressor from
54
+ # the "yui-compressor" gem, or the internal Closure Compiler from the
55
+ # "closure-compiler" gem.
56
+ def initialize
57
+ @css_compressor = YUI::CssCompressor.new(Jammit.css_compressor_options || {})
58
+ flavor = Jammit.javascript_compressor || Jammit::DEFAULT_COMPRESSOR
59
+ @options = DEFAULT_OPTIONS[flavor].merge(Jammit.compressor_options || {})
60
+ @js_compressor = COMPRESSORS[flavor].new(@options)
61
+ end
62
+
63
+ # Concatenate together a list of JavaScript paths, and pass them through the
64
+ # YUI Compressor (with munging enabled). JST can optionally be included.
65
+ def compress_js(paths)
66
+ if (jst_paths = paths.grep(Jammit.jst_extension_regexp)).empty?
67
+ js = concatenate(paths)
68
+ else
69
+ js = concatenate(paths - jst_paths) + compile_jst(jst_paths)
70
+ end
71
+ Jammit.compress_assets ? @js_compressor.compress(js) : js
72
+ end
73
+
74
+ # Concatenate and compress a list of CSS stylesheets. When compressing a
75
+ # :datauri or :mhtml variant, post-processes the result to embed
76
+ # referenced assets.
77
+ def compress_css(paths, variant=nil, asset_url=nil)
78
+ css = concatenate_and_tag_assets(paths, variant)
79
+ css = @css_compressor.compress(css) if Jammit.compress_assets
80
+ case variant
81
+ when nil then return css
82
+ when :datauri then return with_data_uris(css)
83
+ when :mhtml then return with_mhtml(css, asset_url)
84
+ else raise PackageNotFound, "\"#{variant}\" is not a valid stylesheet variant"
85
+ end
86
+ end
87
+
88
+ # Compiles a single JST file by writing out a javascript that adds
89
+ # template properties to a top-level template namespace object. Adds a
90
+ # JST-compilation function to the top of the package, unless you've
91
+ # specified your own preferred function, or turned it off.
92
+ # JST templates are named with the basename of their file.
93
+ def compile_jst(paths)
94
+ namespace = Jammit.template_namespace
95
+ compiled = paths.grep(Jammit.jst_extension_regexp).map do |path|
96
+ contents = File.read(path).gsub(/\n/, '').gsub("'", '\\\\\'')
97
+ template_name = File.basename(path, Jammit.jst_extension)
98
+ if Jammit.template_base_path
99
+ path = Pathname.new(path)
100
+ template_name = path.parent().relative_path_from(Jammit.template_base_path) + template_name
101
+ end
102
+ "#{namespace}['#{template_name}'] = #{Jammit.template_function}('#{contents}');"
103
+ end
104
+ compiler = Jammit.include_jst_script ? File.read(DEFAULT_JST_SCRIPT) : '';
105
+ setup_namespace = "#{namespace} = #{namespace} || {};"
106
+ [JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
107
+ end
108
+
109
+
110
+ private
111
+
112
+ # In order to support embedded assets from relative paths, we need to
113
+ # expand the paths before contatenating the CSS together and losing the
114
+ # location of the original stylesheet path. Validate the assets while we're
115
+ # at it.
116
+ def concatenate_and_tag_assets(paths, variant=nil)
117
+ stylesheets = [paths].flatten.map do |css_path|
118
+ File.read(css_path).gsub(EMBED_DETECTOR) do |url|
119
+ ipath, cpath = Pathname.new($1), Pathname.new(File.expand_path(css_path))
120
+ is_url = URI.parse($1).absolute?
121
+ is_url ? url : "url(#{construct_asset_path(ipath, cpath, variant)})"
122
+ end
123
+ end
124
+ stylesheets.join("\n")
125
+ end
126
+
127
+ # Re-write all enabled asset URLs in a stylesheet with their corresponding
128
+ # Data-URI Base-64 encoded asset contents.
129
+ def with_data_uris(css)
130
+ css.gsub(EMBED_REPLACER) do |url|
131
+ "url(\"data:#{mime_type($1)};charset=utf-8;base64,#{encoded_contents($1)}\")"
132
+ end
133
+ end
134
+
135
+ # Re-write all enabled asset URLs in a stylesheet with the MHTML equivalent.
136
+ # The newlines ("\r\n") in the following method are critical. Without them
137
+ # your MHTML will look identical, but won't work.
138
+ def with_mhtml(css, asset_url)
139
+ paths, index = {}, 0
140
+ css = css.gsub(EMBED_REPLACER) do |url|
141
+ i = paths[$1] ||= "#{index += 1}-#{File.basename($1)}"
142
+ "url(mhtml:#{asset_url}!#{i})"
143
+ end
144
+ mhtml = paths.sort.map do |path, identifier|
145
+ mime, contents = mime_type(path), encoded_contents(path)
146
+ [MHTML_SEPARATOR, "Content-Location: #{identifier}\r\n", "Content-Type: #{mime}\r\n", "Content-Transfer-Encoding: base64\r\n\r\n", contents, "\r\n"]
147
+ end
148
+ [MHTML_START, mhtml, MHTML_END, css].flatten.join('')
149
+ end
150
+
151
+ # Return a rewritten asset URL for a new stylesheet -- the asset should
152
+ # be tagged for embedding if embeddable, and referenced at the correct level
153
+ # if relative.
154
+ def construct_asset_path(asset_path, css_path, variant)
155
+ public_path = absolute_path(asset_path, css_path)
156
+ return "__EMBED__#{public_path}" if embeddable?(public_path, variant)
157
+ source = asset_path.absolute? ? asset_path.to_s : relative_path(public_path)
158
+ rewrite_asset_path(source, public_path)
159
+ end
160
+
161
+ # Get the site-absolute public path for an asset file path that may or may
162
+ # not be relative, given the path of the stylesheet that contains it.
163
+ def absolute_path(asset_pathname, css_pathname)
164
+ (asset_pathname.absolute? ?
165
+ Pathname.new(File.join(PUBLIC_ROOT, asset_pathname)) :
166
+ css_pathname.dirname + asset_pathname).cleanpath
167
+ end
168
+
169
+ # CSS assets that are referenced by relative paths, and are *not* being
170
+ # embedded, must be rewritten relative to the newly-merged stylesheet path.
171
+ def relative_path(absolute_path)
172
+ File.join('../', absolute_path.sub(PUBLIC_ROOT, ''))
173
+ end
174
+
175
+ # Similar to the AssetTagHelper's method of the same name, this will
176
+ # append the RAILS_ASSET_ID cache-buster to URLs, if it's defined.
177
+ def rewrite_asset_path(path, file_path)
178
+ asset_id = rails_asset_id(file_path)
179
+ asset_id.blank? ? path : "#{path}?#{asset_id}"
180
+ end
181
+
182
+ # Similar to the AssetTagHelper's method of the same name, this will
183
+ # determine the correct asset id for a file.
184
+ def rails_asset_id(path)
185
+ asset_id = ENV["RAILS_ASSET_ID"]
186
+ return asset_id if asset_id
187
+ File.exists?(path) ? File.mtime(path).to_i.to_s : ''
188
+ end
189
+
190
+ # An asset is valid for embedding if it exists, is less than 32K, and is
191
+ # stored somewhere inside of a folder named "embed".
192
+ # IE does not support Data-URIs larger than 32K, and you probably shouldn't
193
+ # be embedding assets that large in any case.
194
+ def embeddable?(asset_path, variant)
195
+ font = EMBED_FONTS.include?(asset_path.extname)
196
+ return false unless variant
197
+ return false unless asset_path.to_s.match(EMBEDDABLE) && asset_path.exist?
198
+ return false unless EMBED_EXTS.include?(asset_path.extname)
199
+ return false unless font || asset_path.size < MAX_IMAGE_SIZE
200
+ return false if font && variant == :mhtml
201
+ true
202
+ end
203
+
204
+ # Return the Base64-encoded contents of an asset on a single line.
205
+ def encoded_contents(asset_path)
206
+ data = File.open(asset_path, 'rb'){|f| f.read }
207
+ Base64.encode64(data).gsub(/\n/, '')
208
+ end
209
+
210
+ # Grab the mime-type of an asset, by filename.
211
+ def mime_type(asset_path)
212
+ EMBED_MIME_TYPES[File.extname(asset_path)]
213
+ end
214
+
215
+ # Concatenate together a list of asset files.
216
+ def concatenate(paths)
217
+ [paths].flatten.map {|p| File.read(p) }.join("\n")
218
+ end
219
+
220
+ end
221
+
222
+ end
@@ -0,0 +1,96 @@
1
+ module Jammit
2
+
3
+ # The JammitController is added to your Rails application when the Gem is
4
+ # loaded. It takes responsibility for /assets, and dynamically packages any
5
+ # missing or uncached asset packages.
6
+ class Controller < ActionController::Base
7
+
8
+ VALID_FORMATS = [:css, :js]
9
+
10
+ SUFFIX_STRIPPER = /-(datauri|mhtml)\Z/
11
+
12
+ NOT_FOUND_PATH = "#{PUBLIC_ROOT}/404.html"
13
+
14
+ # The "package" action receives all requests for asset packages that haven't
15
+ # yet been cached. The package will be built, cached, and gzipped.
16
+ def package
17
+ parse_request
18
+ case @extension
19
+ when :js
20
+ if @package.to_s =~ /\A(.*)__templates__\Z/
21
+ render :js => (@contents = Jammit.packager.pack_templates($~[1].to_sym))
22
+ else
23
+ render :js => (@contents = Jammit.packager.pack_javascripts(@package))
24
+ end
25
+ when :css
26
+ render :text => generate_stylesheets, :content_type => 'text/css'
27
+ end
28
+ cache_package if perform_caching
29
+ rescue Jammit::PackageNotFound
30
+ package_not_found
31
+ end
32
+
33
+
34
+ private
35
+
36
+ # Tells the Jammit::Packager to cache and gzip an asset package. We can't
37
+ # just use the built-in "cache_page" because we need to ensure that
38
+ # the timestamp that ends up in the MHTML is also on the cached file.
39
+ def cache_package
40
+ dir = File.join(page_cache_directory, Jammit.package_path)
41
+ Jammit.packager.cache(@package, @extension, @contents, dir, @variant, @mtime)
42
+ end
43
+
44
+ # Generate the complete, timestamped, MHTML url -- if we're rendering a
45
+ # dynamic MHTML package, we'll need to put one URL in the response, and a
46
+ # different one into the cached package.
47
+ def prefix_url(path)
48
+ host = request.port == 80 ? request.host : request.host_with_port
49
+ "#{request.protocol}#{host}#{path}"
50
+ end
51
+
52
+ # If we're generating MHTML/CSS, return a stylesheet with the absolute
53
+ # request URL to the client, and cache a version with the timestamped cache
54
+ # URL swapped in.
55
+ def generate_stylesheets
56
+ return @contents = Jammit.packager.pack_stylesheets(@package, @variant) unless @variant == :mhtml
57
+ @mtime = Time.now
58
+ request_url = prefix_url(request.request_uri)
59
+ cached_url = prefix_url(Jammit.asset_url(@package, @extension, @variant, @mtime))
60
+ css = Jammit.packager.pack_stylesheets(@package, @variant, request_url)
61
+ @contents = css.gsub(request_url, cached_url) if perform_caching
62
+ css
63
+ end
64
+
65
+ # Extracts the package name, extension (:css, :js), and variant (:datauri,
66
+ # :mhtml) from the incoming URL.
67
+ def parse_request
68
+ pack = params[:package]
69
+ @extension = params[:extension].to_sym
70
+ raise PackageNotFound unless VALID_FORMATS.include?(@extension)
71
+ if Jammit.embed_assets
72
+ suffix_match = pack.match(SUFFIX_STRIPPER)
73
+ @variant = Jammit.embed_assets && suffix_match && suffix_match[1].to_sym
74
+ pack.sub!(SUFFIX_STRIPPER, '')
75
+ end
76
+ @package = pack.to_sym
77
+ end
78
+
79
+ # Render the 404 page, if one exists, for any packages that don't.
80
+ def package_not_found
81
+ return render(:file => NOT_FOUND_PATH, :status => 404) if File.exists?(NOT_FOUND_PATH)
82
+ render :text => "<h1>404: \"#{@package}\" asset package not found.</h1>", :status => 404
83
+ end
84
+
85
+ end
86
+
87
+ end
88
+
89
+ # Make the Jammit::Controller available to Rails as a top-level controller.
90
+ ::JammitController = Jammit::Controller
91
+
92
+ if defined?(Rails) && Rails.env.development?
93
+ ActionController::Base.class_eval do
94
+ append_before_filter { Jammit.reload! }
95
+ end
96
+ end
@@ -0,0 +1,28 @@
1
+ # Standard Library Dependencies:
2
+ require 'uri'
3
+ require 'erb'
4
+ require 'zlib'
5
+ require 'base64'
6
+ require 'pathname'
7
+ require 'fileutils'
8
+
9
+ # Gem Dependencies:
10
+ require 'rubygems'
11
+ gem 'rails', '~> 2.0'
12
+ require 'yui/compressor'
13
+ require 'closure-compiler'
14
+ require 'active_support'
15
+ require 'active_support/core_ext/hash'
16
+
17
+ # Load initial configuration before the rest of Jammit.
18
+ Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH) if defined?(Rails)
19
+
20
+ # Jammit Core:
21
+ require 'jammit/compressor'
22
+ require 'jammit/packager'
23
+
24
+ # Jammit Rails Integration:
25
+ if defined?(Rails)
26
+ require 'jammit/controller' # Rails will auto-load 'jammit/helper' for us.
27
+ require 'jammit/routes'
28
+ end
@@ -0,0 +1,77 @@
1
+ module Jammit
2
+
3
+ # The Jammit::Helper module, which is made available to every view, provides
4
+ # helpers for writing out HTML tags for asset packages. In development you
5
+ # get the ordered list of source files -- in any other environment, a link
6
+ # to the cached packages.
7
+ module Helper
8
+
9
+ DATA_URI_START = "<!--[if (!IE)|(gte IE 8)]><!-->"
10
+ DATA_URI_END = "<!--<![endif]-->"
11
+ MHTML_START = "<!--[if lte IE 7]>"
12
+ MHTML_END = "<![endif]-->"
13
+
14
+ # If embed_assets is turned on, writes out links to the Data-URI and MHTML
15
+ # versions of the stylesheet package, otherwise the package is regular
16
+ # compressed CSS, and in development the stylesheet URLs are passed verbatim.
17
+ def include_stylesheets(*packages)
18
+ options = packages.extract_options!
19
+ return individual_stylesheets(packages, options) unless Jammit.package_assets
20
+ disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
21
+ return packaged_stylesheets(packages, options) if disabled || !Jammit.embed_assets
22
+ return embedded_image_stylesheets(packages, options)
23
+ end
24
+
25
+ # Writes out the URL to the bundled and compressed javascript package,
26
+ # except in development, where it references the individual scripts.
27
+ def include_javascripts(*packages)
28
+ tags = packages.map do |pack|
29
+ Jammit.package_assets ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
30
+ end
31
+ javascript_include_tag(tags.flatten)
32
+ end
33
+
34
+ # Writes out the URL to the concatenated and compiled JST file -- we always
35
+ # have to pre-process it, even in development.
36
+ def include_templates(*packages)
37
+ raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nYou can include your JST alongside your JS, and use include_javascripts."
38
+ end
39
+
40
+
41
+ private
42
+
43
+ # HTML tags, in order, for all of the individual stylesheets.
44
+ def individual_stylesheets(packages, options)
45
+ tags_with_options(packages, options) {|p| Jammit.packager.individual_urls(p.to_sym, :css) }
46
+ end
47
+
48
+ # HTML tags for the stylesheet packages.
49
+ def packaged_stylesheets(packages, options)
50
+ tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css) }
51
+ end
52
+
53
+ # HTML tags for the 'datauri', and 'mhtml' versions of the packaged
54
+ # stylesheets, using conditional comments to load the correct variant.
55
+ def embedded_image_stylesheets(packages, options)
56
+ datauri_tags = tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :datauri) }
57
+ ie_tags = Jammit.mhtml_enabled ?
58
+ tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :mhtml) } :
59
+ packaged_stylesheets(packages, options)
60
+ [DATA_URI_START, datauri_tags, DATA_URI_END, MHTML_START, ie_tags, MHTML_END].join("\n")
61
+ end
62
+
63
+ # Generate the stylesheet tags for a batch of packages, with options, by
64
+ # yielding each package to a block.
65
+ def tags_with_options(packages, options)
66
+ packages = packages.dup
67
+ packages.map! {|package| yield package }.flatten!
68
+ packages.push(options) unless options.empty?
69
+ stylesheet_link_tag(*packages)
70
+ end
71
+
72
+ end
73
+
74
+ end
75
+
76
+ # Include the Jammit asset helpers in all views, a-la ApplicationHelper.
77
+ ::ActionView::Base.send(:include, Jammit::Helper)
@@ -0,0 +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, " ").replace(/'(?=[^%]*%>)/g,"\t").split("'").join("\\'").split("\t").join("'").replace(/<%=(.+?)%>/g,"',$1,'").split("<%").join("');").split("%>").join("p.push('")+"');}return p.join('');"); return fn;};
@@ -0,0 +1,155 @@
1
+ module Jammit
2
+
3
+ # The Jammit::Packager resolves the configuration file into lists of real
4
+ # assets that get merged into individual asset packages. Given the compiled
5
+ # contents of an asset package, the Packager knows how to cache that package
6
+ # with the correct timestamps.
7
+ class Packager
8
+
9
+ # In Rails, the difference between a path and an asset URL is "public".
10
+ PATH_DIFF = PUBLIC_ROOT.sub(ASSET_ROOT, '')
11
+ PATH_TO_URL = /\A#{Regexp.escape(ASSET_ROOT)}(\/?#{Regexp.escape(PATH_DIFF)})?/
12
+
13
+ # Set force to false to allow packages to only be rebuilt when their source
14
+ # files have changed since the last time their package was built.
15
+ attr_accessor :force
16
+
17
+ # Creating a new Packager will rebuild the list of assets from the
18
+ # Jammit.configuration. When assets.yml is being changed on the fly,
19
+ # create a new Packager.
20
+ def initialize
21
+ @compressor = Compressor.new
22
+ @force = false
23
+ @config = {
24
+ :css => (Jammit.configuration[:stylesheets] || {}).symbolize_keys,
25
+ :js => (Jammit.configuration[:javascripts] || {}).symbolize_keys
26
+ }
27
+ @packages = {
28
+ :css => create_packages(@config[:css]),
29
+ :js => create_packages(@config[:js])
30
+ }
31
+ end
32
+
33
+ # Ask the packager to precache all defined assets, along with their gzip'd
34
+ # versions. In order to prebuild the MHTML stylesheets, we need to know the
35
+ # base_url, because IE only supports MHTML with absolute references.
36
+ # Unless forced, will only rebuild assets whose source files have been
37
+ # changed since their last package build.
38
+ def precache_all(output_dir=nil, base_url=nil)
39
+ output_dir ||= File.join(PUBLIC_ROOT, Jammit.package_path)
40
+ cacheable(:js, output_dir).each {|p| cache(p, 'js', pack_javascripts(p), output_dir) }
41
+ cacheable(:css, output_dir).each do |p|
42
+ cache(p, 'css', pack_stylesheets(p), output_dir)
43
+ if Jammit.embed_assets
44
+ cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
45
+ if Jammit.mhtml_enabled && base_url
46
+ mtime = Time.now
47
+ asset_url = "#{base_url}#{Jammit.asset_url(p, :css, :mhtml, mtime)}"
48
+ cache(p, 'css', pack_stylesheets(p, :mhtml, asset_url), output_dir, :mhtml, mtime)
49
+ end
50
+ end
51
+ end
52
+ end
53
+
54
+ # Caches a single prebuilt asset package and gzips it at the highest
55
+ # compression level. Ensures that the modification time of both both
56
+ # variants is identical, for web server caching modules, as well as MHTML.
57
+ def cache(package, extension, contents, output_dir, suffix=nil, mtime=Time.now)
58
+ FileUtils.mkdir_p(output_dir) unless File.exists?(output_dir)
59
+ raise OutputNotWritable, "Jammit doesn't have permission to write to \"#{output_dir}\"" unless File.writable?(output_dir)
60
+ files = []
61
+ files << file_name = File.join(output_dir, Jammit.filename(package, extension, suffix))
62
+ File.open(file_name, 'wb+') {|f| f.write(contents) }
63
+ if Jammit.gzip_assets
64
+ files << zip_name = "#{file_name}.gz"
65
+ Zlib::GzipWriter.open(zip_name, Zlib::BEST_COMPRESSION) {|f| f.write(contents) }
66
+ end
67
+ File.utime(mtime, mtime, *files)
68
+ end
69
+
70
+ # Get the list of individual assets for a package.
71
+ def individual_urls(package, extension)
72
+ package_for(package, extension)[:urls]
73
+ end
74
+
75
+ # Return the compressed contents of a stylesheet package.
76
+ def pack_stylesheets(package, variant=nil, asset_url=nil)
77
+ @compressor.compress_css(package_for(package, :css)[:paths], variant, asset_url)
78
+ end
79
+
80
+ # Return the compressed contents of a javascript package.
81
+ def pack_javascripts(package)
82
+ @compressor.compress_js(package_for(package, :js)[:paths])
83
+ end
84
+
85
+ # Return the compiled contents of a JST package.
86
+ def pack_templates(package)
87
+ @compressor.compile_jst(package_for(package, :js)[:paths])
88
+ end
89
+
90
+ private
91
+
92
+ # Look up a package asset list by name, raising an exception if the
93
+ # package has gone missing.
94
+ def package_for(package, extension)
95
+ pack = @packages[extension] && @packages[extension][package]
96
+ pack || not_found(package, extension)
97
+ end
98
+
99
+ # Absolute globs are absolute -- relative globs are relative to ASSET_ROOT.
100
+ # Print a warning if no files were found that match the glob.
101
+ def glob_files(glob)
102
+ absolute = Pathname.new(glob).absolute?
103
+ paths = Dir[absolute ? glob : File.join(ASSET_ROOT, glob)].sort
104
+ Jammit.warn("No assets match '#{glob}'") if paths.empty?
105
+ paths
106
+ end
107
+
108
+ # Return a list of all of the packages that should be cached. If "force" is
109
+ # true, this is all of them -- otherwise only the packages whose source
110
+ # files have changed since the last package build.
111
+ def cacheable(extension, output_dir)
112
+ names = @packages[extension].keys
113
+ return names if @force
114
+ return names.select do |name|
115
+ pack = package_for(name, extension)
116
+ cached = File.join(output_dir, Jammit.filename(name, extension))
117
+ since = File.exists?(cached) && File.mtime(cached)
118
+ !since || pack[:paths].any? {|src| File.mtime(src) > since }
119
+ end
120
+ end
121
+
122
+ # Compiles the list of assets that goes into each package. Runs an ordered
123
+ # list of Dir.globs, taking the merged unique result.
124
+ def create_packages(config)
125
+ packages = {}
126
+ return packages if !config
127
+ config.each do |name, globs|
128
+ globs ||= []
129
+ packages[name] = {}
130
+ paths = globs.flatten.uniq.map {|glob| glob_files(glob) }.flatten.uniq
131
+ packages[name][:paths] = paths
132
+ # Check for JST.
133
+ if !paths.grep(Jammit.jst_extension_regexp).empty?
134
+ # If there are JST files in this package we need to add an extra
135
+ # path for when package_assets is off (e.g. in a dev environment).
136
+ # This package (e.g. /assets/package-name__templates__.js) will
137
+ # never exist as an actual file but will be dynamically generated by
138
+ # Jammit on every request.
139
+ packages[name][:urls] = paths.grep(JS_EXTENSION).map {|path| path.sub(PATH_TO_URL, '') }
140
+ packages[name][:urls] += [Jammit.asset_url("#{name}__templates__", :js)]
141
+ else
142
+ packages[name][:urls] = paths.map {|path| path.sub(PATH_TO_URL, '') }
143
+ end
144
+ end
145
+ packages
146
+ end
147
+
148
+ # Raise a PackageNotFound exception for missing packages...
149
+ def not_found(package, extension)
150
+ raise PackageNotFound, "assets.yml does not contain a \"#{package}\" #{extension.to_s.upcase} package"
151
+ end
152
+
153
+ end
154
+
155
+ end
@@ -0,0 +1,25 @@
1
+ module Jammit
2
+
3
+ # Rails 2.x routing module.
4
+ module Routes
5
+
6
+ # Jammit uses a single route in order to slow down Rails' routing speed
7
+ # by the absolute minimum. In your config/routes.rb file, call:
8
+ # Jammit::Routes.draw(map)
9
+ # Passing in the routing "map" object.
10
+ def self.draw(map)
11
+ map.jammit "/#{Jammit.package_path}/:package.:extension",
12
+ :controller => 'jammit', :action => 'package'
13
+ end
14
+
15
+ end
16
+
17
+ end
18
+
19
+ # Rails 3.x routes.
20
+ if defined?(Jammit::Railtie)
21
+ Jammit::Railtie.routes do
22
+ match "/#{Jammit.package_path}/:package.:extension",
23
+ :to => 'jammit#package', :as => 'jammit'
24
+ end
25
+ end
metadata ADDED
@@ -0,0 +1,121 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: agibralter-jammit
3
+ version: !ruby/object:Gem::Version
4
+ prerelease: false
5
+ segments:
6
+ - 0
7
+ - 5
8
+ - 0
9
+ version: 0.5.0
10
+ platform: ruby
11
+ authors:
12
+ - Jeremy Ashkenas
13
+ autorequire:
14
+ bindir: bin
15
+ cert_chain: []
16
+
17
+ date: 2010-04-30 00:00:00 -04:00
18
+ default_executable:
19
+ dependencies:
20
+ - !ruby/object:Gem::Dependency
21
+ name: rails
22
+ prerelease: false
23
+ requirement: &id001 !ruby/object:Gem::Requirement
24
+ requirements:
25
+ - - ">="
26
+ - !ruby/object:Gem::Version
27
+ segments:
28
+ - 2
29
+ - 0
30
+ - 0
31
+ version: 2.0.0
32
+ type: :runtime
33
+ version_requirements: *id001
34
+ - !ruby/object:Gem::Dependency
35
+ name: yui-compressor
36
+ prerelease: false
37
+ requirement: &id002 !ruby/object:Gem::Requirement
38
+ requirements:
39
+ - - ">="
40
+ - !ruby/object:Gem::Version
41
+ segments:
42
+ - 0
43
+ - 9
44
+ - 1
45
+ version: 0.9.1
46
+ type: :runtime
47
+ version_requirements: *id002
48
+ - !ruby/object:Gem::Dependency
49
+ name: closure-compiler
50
+ prerelease: false
51
+ requirement: &id003 !ruby/object:Gem::Requirement
52
+ requirements:
53
+ - - ">="
54
+ - !ruby/object:Gem::Version
55
+ segments:
56
+ - 0
57
+ - 1
58
+ - 0
59
+ version: 0.1.0
60
+ type: :runtime
61
+ version_requirements: *id003
62
+ 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"
63
+ email: jeremy@documentcloud.org
64
+ executables:
65
+ - jammit
66
+ extensions: []
67
+
68
+ extra_rdoc_files:
69
+ - README
70
+ files:
71
+ - lib/jammit/command_line.rb
72
+ - lib/jammit/compressor.rb
73
+ - lib/jammit/controller.rb
74
+ - lib/jammit/dependencies.rb
75
+ - lib/jammit/helper.rb
76
+ - lib/jammit/jst.js
77
+ - lib/jammit/packager.rb
78
+ - lib/jammit/routes.rb
79
+ - lib/jammit.rb
80
+ - bin/jammit
81
+ - jammit.gemspec
82
+ - LICENSE
83
+ - README
84
+ has_rdoc: true
85
+ homepage: http://documentcloud.github.com/jammit/
86
+ licenses: []
87
+
88
+ post_install_message:
89
+ rdoc_options:
90
+ - --title
91
+ - Jammit
92
+ - --exclude
93
+ - test
94
+ - --main
95
+ - README
96
+ - --all
97
+ require_paths:
98
+ - lib
99
+ required_ruby_version: !ruby/object:Gem::Requirement
100
+ requirements:
101
+ - - ">="
102
+ - !ruby/object:Gem::Version
103
+ segments:
104
+ - 0
105
+ version: "0"
106
+ required_rubygems_version: !ruby/object:Gem::Requirement
107
+ requirements:
108
+ - - ">="
109
+ - !ruby/object:Gem::Version
110
+ segments:
111
+ - 0
112
+ version: "0"
113
+ requirements: []
114
+
115
+ rubyforge_project: jammit
116
+ rubygems_version: 1.3.6
117
+ signing_key:
118
+ specification_version: 3
119
+ summary: Industrial Strength Asset Packaging for Rails
120
+ test_files: []
121
+