alegscogs_jammit 0.6.3.alegscogs

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,221 @@
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.6.3"
8
+
9
+ ROOT = File.expand_path(File.dirname(__FILE__) + '/..')
10
+
11
+ ASSET_ROOT = File.expand_path((defined?(Rails) && Rails.root.to_s.length > 0) ? Rails.root : ENV['RAILS_ROOT'] || ".") unless defined?(ASSET_ROOT)
12
+
13
+ DEFAULT_PUBLIC_ROOT = (defined?(Rails) && Rails.public_path.to_s.length > 0) ? Rails.public_path : File.join(ASSET_ROOT, 'public') unless defined?(PUBLIC_ROOT)
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
+ COMPRESSORS = [:yui, :closure, :uglifier]
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 MissingConfiguration exception when you try to load the
38
+ # configuration of an assets.yml file that doesn't exist, or are missing
39
+ # a piece of required configuration.
40
+ class MissingConfiguration < NameError; end
41
+
42
+ # Jammit raises an OutputNotWritable exception if the output directory for
43
+ # cached packages is locked.
44
+ class OutputNotWritable < StandardError; end
45
+
46
+ # Jammit raises a DeprecationError if you try to use an outdated feature.
47
+ class DeprecationError < StandardError; end
48
+
49
+ class << self
50
+ attr_reader :configuration, :template_function, :template_namespace,
51
+ :embed_assets, :package_assets, :compress_assets, :gzip_assets,
52
+ :package_path, :mhtml_enabled, :include_jst_script, :config_path,
53
+ :javascript_compressor, :compressor_options, :css_compressor_options,
54
+ :template_extension, :template_extension_matcher, :allow_debugging,
55
+ :public_root
56
+ attr_accessor :compressors
57
+ end
58
+
59
+ # The minimal required configuration.
60
+ @configuration = {}
61
+ @public_root = DEFAULT_PUBLIC_ROOT
62
+ @package_path = DEFAULT_PACKAGE_PATH
63
+ @compressors = COMPRESSORS
64
+
65
+ # Load the complete asset configuration from the specified @config_path@.
66
+ # If we're loading softly, don't let missing configuration error out.
67
+ def self.load_configuration(config_path, soft=false)
68
+ exists = config_path && File.exists?(config_path)
69
+ return false if soft && !exists
70
+ raise MissingConfiguration, "could not find the \"#{config_path}\" configuration file" unless exists
71
+ conf = YAML.load(ERB.new(File.read(config_path)).result)
72
+
73
+ # Optionally overwrite configuration based on the environment.
74
+ rails_env = defined?(Rails) ? Rails.env : ENV['RAILS_ENV']
75
+ conf.merge! conf.delete rails_env if conf.has_key? rails_env
76
+
77
+ @config_path = config_path
78
+ @configuration = symbolize_keys(conf)
79
+ @package_path = conf[:package_path] || DEFAULT_PACKAGE_PATH
80
+ @embed_assets = conf[:embed_assets] || conf[:embed_images]
81
+ @compress_assets = !(conf[:compress_assets] == false)
82
+ @gzip_assets = !(conf[:gzip_assets] == false)
83
+ @allow_debugging = !(conf[:allow_debugging] == false)
84
+ @mhtml_enabled = @embed_assets && @embed_assets != "datauri"
85
+ @compressor_options = symbolize_keys(conf[:compressor_options] || {})
86
+ @css_compressor_options = symbolize_keys(conf[:css_compressor_options] || {})
87
+ set_javascript_compressor(conf[:javascript_compressor])
88
+ set_package_assets(conf[:package_assets])
89
+ set_template_function(conf[:template_function])
90
+ set_template_namespace(conf[:template_namespace])
91
+ set_template_extension(conf[:template_extension])
92
+ set_public_root(conf[:public_root]) if conf[:public_root]
93
+ symbolize_keys(conf[:stylesheets]) if conf[:stylesheets]
94
+ symbolize_keys(conf[:javascripts]) if conf[:javascripts]
95
+ check_for_deprecations
96
+ self
97
+ end
98
+
99
+ # Force a reload by resetting the Packager and reloading the configuration.
100
+ # In development, this will be called as a before_filter before every request.
101
+ def self.reload!
102
+ Thread.current[:jammit_packager] = nil
103
+ load_configuration(@config_path)
104
+ end
105
+
106
+ # Keep a global (thread-local) reference to a @Jammit::Packager@, to avoid
107
+ # recomputing asset lists unnecessarily.
108
+ def self.packager
109
+ Thread.current[:jammit_packager] ||= Packager.new
110
+ end
111
+
112
+ # Generate the base filename for a version of a given package.
113
+ def self.filename(package, extension, suffix=nil)
114
+ suffix_part = suffix ? "-#{suffix}" : ''
115
+ "#{package}#{suffix_part}.#{extension}"
116
+ end
117
+
118
+ # Generates the server-absolute URL to an asset package.
119
+ def self.asset_url(package, extension, suffix=nil, mtime=nil)
120
+ timestamp = mtime ? "?#{mtime.to_i}" : ''
121
+ "/#{package_path}/#{filename(package, extension, suffix)}#{timestamp}"
122
+ end
123
+
124
+ # Convenience method for packaging up Jammit, using the default options.
125
+ def self.package!(options={})
126
+ options = {
127
+ :config_path => Jammit::DEFAULT_CONFIG_PATH,
128
+ :output_folder => nil,
129
+ :base_url => nil,
130
+ :public_root => nil,
131
+ :force => false
132
+ }.merge(options)
133
+ load_configuration(options[:config_path])
134
+ set_public_root(options[:public_root]) if options[:public_root]
135
+ packager.force = options[:force]
136
+ packager.package_names = options[:package_names]
137
+ packager.precache_all(options[:output_folder], options[:base_url])
138
+ end
139
+
140
+ private
141
+
142
+ # Allows command-line definition of `PUBLIC_ROOT`, for those using Jammit
143
+ # outside of Rails.
144
+ def self.set_public_root(public_root=nil)
145
+ @public_root = public_root if public_root
146
+ end
147
+
148
+ # Ensure that the JavaScript compressor is a valid choice.
149
+ def self.set_javascript_compressor(value)
150
+ value = value && value.to_sym
151
+ @javascript_compressor = compressors.include?(value) ? value : DEFAULT_COMPRESSOR
152
+ end
153
+
154
+ # Turn asset packaging on or off, depending on configuration and environment.
155
+ def self.set_package_assets(value)
156
+ package_env = !defined?(Rails) || (!Rails.env.development? && !Rails.env.test?)
157
+ @package_assets = value == true || value.nil? ? package_env :
158
+ value == 'always' ? true : false
159
+ end
160
+
161
+ # Assign the JST template function, unless explicitly turned off.
162
+ def self.set_template_function(value)
163
+ @template_function = value == true || value.nil? ? DEFAULT_JST_COMPILER :
164
+ value == false ? '' : value
165
+ @include_jst_script = @template_function == DEFAULT_JST_COMPILER
166
+ end
167
+
168
+ # Set the root JS object in which to stash all compiled JST.
169
+ def self.set_template_namespace(value)
170
+ @template_namespace = value == true || value.nil? ? DEFAULT_JST_NAMESPACE : value.to_s
171
+ end
172
+
173
+ # Set the extension for JS templates.
174
+ def self.set_template_extension(value)
175
+ @template_extension = (value == true || value.nil? ? DEFAULT_JST_EXTENSION : value.to_s).gsub(/\A\.?(.*)\Z/, '\1')
176
+ @template_extension_matcher = /\.#{Regexp.escape(@template_extension)}\Z/
177
+ end
178
+
179
+ # The YUI Compressor requires Java > 1.4, and Closure requires Java > 1.6.
180
+ def self.check_java_version
181
+ return true if @checked_java_version
182
+ java = @compressor_options[:java] || 'java'
183
+ @css_compressor_options[:java] ||= java if @compressor_options[:java]
184
+ version = (`#{java} -version 2>&1`)[/\d+\.\d+/]
185
+ disable_compression if !version ||
186
+ (@javascript_compressor == :closure && version < '1.6') ||
187
+ (@javascript_compressor == :yui && version < '1.4')
188
+ @checked_java_version = true
189
+ end
190
+
191
+ # If we don't have a working Java VM, then disable asset compression and
192
+ # complain loudly.
193
+ def self.disable_compression
194
+ @compress_assets = false
195
+ warn("Asset compression disabled -- Java unavailable.")
196
+ end
197
+
198
+ # Jammit 0.5+ no longer supports separate template packages.
199
+ def self.check_for_deprecations
200
+ if @configuration[:templates]
201
+ raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nPlease fold your templates into the appropriate 'javascripts' package instead."
202
+ end
203
+ end
204
+
205
+ def self.warn(message)
206
+ message = "Jammit Warning: #{message}"
207
+ $stderr.puts message
208
+ end
209
+
210
+ # Clone of active_support's symbolize_keys, so that we don't have to depend
211
+ # on active_support in any fashion. Converts a hash's keys to all symbols.
212
+ def self.symbolize_keys(hash)
213
+ hash.keys.each do |key|
214
+ hash[(key.to_sym rescue key) || key] = hash.delete(key)
215
+ end
216
+ hash
217
+ end
218
+
219
+ end
220
+
221
+ require 'jammit/dependencies'
@@ -0,0 +1,84 @@
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.package!(@options)
30
+ end
31
+
32
+
33
+ private
34
+
35
+ # Make sure that we have a readable configuration file. The @jammit@
36
+ # command can't run without one.
37
+ def ensure_configuration_file
38
+ config = @options[:config_path]
39
+ return true if File.exists?(config) && File.readable?(config)
40
+ puts "Could not find the asset configuration file \"#{config}\""
41
+ exit(1)
42
+ end
43
+
44
+ # Uses @OptionParser@ to grab the options: *--output*, *--config*, and
45
+ # *--base-url*...
46
+ def parse_options
47
+ @options = {
48
+ :config_path => Jammit::DEFAULT_CONFIG_PATH,
49
+ :output_folder => nil,
50
+ :base_url => nil,
51
+ :force => false
52
+ }
53
+ @option_parser = OptionParser.new do |opts|
54
+ opts.on('-o', '--output PATH', 'output folder for packages (default: "public/assets")') do |output_folder|
55
+ @options[:output_folder] = output_folder
56
+ end
57
+ opts.on('-c', '--config PATH', 'path to assets.yml (default: "config/assets.yml")') do |config_path|
58
+ @options[:config_path] = config_path
59
+ end
60
+ opts.on('-u', '--base-url URL', 'base URL for MHTML (ex: "http://example.com")') do |base_url|
61
+ @options[:base_url] = base_url
62
+ end
63
+ opts.on('-f', '--force', 'force a rebuild of all assets') do |force|
64
+ @options[:force] = force
65
+ end
66
+ opts.on('-p', '--packages LIST', 'list of packages to build (ex: "core,ui", default: all)') do |package_names|
67
+ @options[:package_names] = package_names.split(/,\s*/).map {|n| n.to_sym }
68
+ end
69
+ opts.on('-P', '--public-root PATH', 'path to public assets (default: "public")') do |public_root|
70
+ puts "Option for PUBLIC_ROOT"
71
+ @options[:public_root] = public_root
72
+ end
73
+ opts.on_tail('-v', '--version', 'display Jammit version') do
74
+ puts "Jammit version #{Jammit::VERSION}"
75
+ exit
76
+ end
77
+ end
78
+ @option_parser.banner = BANNER
79
+ @option_parser.parse!(ARGV)
80
+ end
81
+
82
+ end
83
+
84
+ end
@@ -0,0 +1,253 @@
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
+ '.woff' => 'font/woff'
21
+ }
22
+
23
+ # Font extensions for which we allow embedding:
24
+ EMBED_EXTS = EMBED_MIME_TYPES.keys
25
+ EMBED_FONTS = ['.ttf', '.otf', '.woff']
26
+
27
+ # (32k - padding) maximum length for data-uri assets (an IE8 limitation).
28
+ MAX_IMAGE_SIZE = 32700
29
+
30
+ # CSS asset-embedding regexes for URL rewriting.
31
+ EMBED_DETECTOR = /url\(['"]?([^\s)]+\.[a-z]+)(\?\d+)?['"]?\)/
32
+ EMBEDDABLE = /[\A\/]embed\//
33
+ EMBED_REPLACER = /url\(__EMBED__(.+?)(\?\d+)?\)/
34
+
35
+ # MHTML file constants.
36
+ MHTML_START = "/*\r\nContent-Type: multipart/related; boundary=\"MHTML_MARK\"\r\n\r\n"
37
+ MHTML_SEPARATOR = "--MHTML_MARK\r\n"
38
+ MHTML_END = "\r\n--MHTML_MARK--\r\n*/\r\n"
39
+
40
+ # JST file constants.
41
+ JST_START = "(function(){"
42
+ JST_END = "})();"
43
+
44
+ COMPRESSORS = {
45
+ :yui => YUI::JavaScriptCompressor,
46
+ :closure => Jammit.compressors.include?(:closure) ? Closure::Compiler : nil,
47
+ :uglifier => Jammit.compressors.include?(:uglifier) ? Jammit::Uglifier : nil
48
+ }
49
+
50
+ DEFAULT_OPTIONS = {
51
+ :yui => {:munge => true},
52
+ :closure => {},
53
+ :uglifier => {:copyright => false}
54
+ }
55
+
56
+ # The css compressor is always the YUI Compressor. JS compression can be
57
+ # provided with YUI Compressor, Google Closure Compiler or UglifyJS.
58
+ def initialize
59
+ Jammit.check_java_version
60
+ @css_compressor = YUI::CssCompressor.new(Jammit.css_compressor_options || {})
61
+ flavor = Jammit.javascript_compressor || Jammit::DEFAULT_COMPRESSOR
62
+ @options = DEFAULT_OPTIONS[flavor].merge(Jammit.compressor_options || {})
63
+ @js_compressor = COMPRESSORS[flavor].new(@options)
64
+ end
65
+
66
+ # Concatenate together a list of JavaScript paths, and pass them through the
67
+ # YUI Compressor (with munging enabled). JST can optionally be included.
68
+ def compress_js(paths)
69
+ if (jst_paths = paths.grep(Jammit.template_extension_matcher)).empty?
70
+ js = concatenate(paths)
71
+ else
72
+ js = concatenate(paths - jst_paths) + compile_jst(jst_paths)
73
+ end
74
+ Jammit.compress_assets ? @js_compressor.compress(js) : js
75
+ end
76
+
77
+ # Concatenate and compress a list of CSS stylesheets. When compressing a
78
+ # :datauri or :mhtml variant, post-processes the result to embed
79
+ # referenced assets.
80
+ def compress_css(paths, variant=nil, asset_url=nil)
81
+ @asset_contents = {}
82
+ css = concatenate_and_tag_assets(paths, variant)
83
+ css = @css_compressor.compress(css) if Jammit.compress_assets
84
+ case variant
85
+ when nil then return css
86
+ when :datauri then return with_data_uris(css)
87
+ when :mhtml then return with_mhtml(css, asset_url)
88
+ else raise PackageNotFound, "\"#{variant}\" is not a valid stylesheet variant"
89
+ end
90
+ end
91
+
92
+ # Compiles a single JST file by writing out a javascript that adds
93
+ # template properties to a top-level template namespace object. Adds a
94
+ # JST-compilation function to the top of the package, unless you've
95
+ # specified your own preferred function, or turned it off.
96
+ # JST templates are named with the basename of their file.
97
+ def compile_jst(paths)
98
+ namespace = Jammit.template_namespace
99
+ paths = paths.grep(Jammit.template_extension_matcher).sort
100
+ base_path = find_base_path(paths)
101
+ compiled = paths.map do |path|
102
+ contents = read_binary_file(path)
103
+ contents = contents.gsub(/\r?\n/, "\\n").gsub("'", '\\\\\'')
104
+ name = template_name(path, base_path)
105
+ "#{namespace}['#{name}'] = #{Jammit.template_function}('#{contents}');"
106
+ end
107
+ compiler = Jammit.include_jst_script ? read_binary_file(DEFAULT_JST_SCRIPT) : '';
108
+ setup_namespace = "#{namespace} = #{namespace} || {};"
109
+ [JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
110
+ end
111
+
112
+
113
+ private
114
+
115
+ # Given a set of paths, find a common prefix path.
116
+ def find_base_path(paths)
117
+ return nil if paths.length <= 1
118
+ paths.sort!
119
+ first = paths.first.split('/')
120
+ last = paths.last.split('/')
121
+ i = 0
122
+ while first[i] == last[i] && i <= first.length
123
+ i += 1
124
+ end
125
+ res = first.slice(0, i).join('/')
126
+ res.empty? ? nil : res
127
+ end
128
+
129
+ # Determine the name of a JS template. If there's a common base path, use
130
+ # the namespaced prefix. Otherwise, simply use the filename.
131
+ def template_name(path, base_path)
132
+ return File.basename(path, ".#{Jammit.template_extension}") unless base_path
133
+ path.gsub(/\A#{Regexp.escape(base_path)}\/(.*)\.#{Jammit.template_extension}\Z/, '\1')
134
+ end
135
+
136
+ # In order to support embedded assets from relative paths, we need to
137
+ # expand the paths before contatenating the CSS together and losing the
138
+ # location of the original stylesheet path. Validate the assets while we're
139
+ # at it.
140
+ def concatenate_and_tag_assets(paths, variant=nil)
141
+ stylesheets = [paths].flatten.map do |css_path|
142
+ contents = read_binary_file(css_path)
143
+ contents.gsub(EMBED_DETECTOR) do |url|
144
+ ipath, cpath = Pathname.new($1), Pathname.new(File.expand_path(css_path))
145
+ is_url = URI.parse($1).absolute?
146
+ is_url ? url : "url(#{construct_asset_path(ipath, cpath, variant)})"
147
+ end
148
+ end
149
+ stylesheets.join("\n")
150
+ end
151
+
152
+ # Re-write all enabled asset URLs in a stylesheet with their corresponding
153
+ # Data-URI Base-64 encoded asset contents.
154
+ def with_data_uris(css)
155
+ css.gsub(EMBED_REPLACER) do |url|
156
+ "url(\"data:#{mime_type($1)};charset=utf-8;base64,#{encoded_contents($1)}\")"
157
+ end
158
+ end
159
+
160
+ # Re-write all enabled asset URLs in a stylesheet with the MHTML equivalent.
161
+ # The newlines ("\r\n") in the following method are critical. Without them
162
+ # your MHTML will look identical, but won't work.
163
+ def with_mhtml(css, asset_url)
164
+ paths, index = {}, 0
165
+ css = css.gsub(EMBED_REPLACER) do |url|
166
+ i = paths[$1] ||= "#{index += 1}-#{File.basename($1)}"
167
+ "url(mhtml:#{asset_url}!#{i})"
168
+ end
169
+ mhtml = paths.sort.map do |path, identifier|
170
+ mime, contents = mime_type(path), encoded_contents(path)
171
+ [MHTML_SEPARATOR, "Content-Location: #{identifier}\r\n", "Content-Type: #{mime}\r\n", "Content-Transfer-Encoding: base64\r\n\r\n", contents, "\r\n"]
172
+ end
173
+ [MHTML_START, mhtml, MHTML_END, css].flatten.join('')
174
+ end
175
+
176
+ # Return a rewritten asset URL for a new stylesheet -- the asset should
177
+ # be tagged for embedding if embeddable, and referenced at the correct level
178
+ # if relative.
179
+ def construct_asset_path(asset_path, css_path, variant)
180
+ public_path = absolute_path(asset_path, css_path)
181
+ return "__EMBED__#{public_path}" if embeddable?(public_path, variant)
182
+ source = asset_path.absolute? ? asset_path.to_s : relative_path(public_path)
183
+ rewrite_asset_path(source, public_path)
184
+ end
185
+
186
+ # Get the site-absolute public path for an asset file path that may or may
187
+ # not be relative, given the path of the stylesheet that contains it.
188
+ def absolute_path(asset_pathname, css_pathname)
189
+ (asset_pathname.absolute? ?
190
+ Pathname.new(File.join(Jammit.public_root, asset_pathname)) :
191
+ css_pathname.dirname + asset_pathname).cleanpath
192
+ end
193
+
194
+ # CSS assets that are referenced by relative paths, and are *not* being
195
+ # embedded, must be rewritten relative to the newly-merged stylesheet path.
196
+ def relative_path(absolute_path)
197
+ File.join('../', absolute_path.sub(Jammit.public_root, ''))
198
+ end
199
+
200
+ # Similar to the AssetTagHelper's method of the same name, this will
201
+ # append the RAILS_ASSET_ID cache-buster to URLs, if it's defined.
202
+ def rewrite_asset_path(path, file_path)
203
+ asset_id = rails_asset_id(file_path)
204
+ (!asset_id || asset_id == '') ? path : "#{path}?#{asset_id}"
205
+ end
206
+
207
+ # Similar to the AssetTagHelper's method of the same name, this will
208
+ # determine the correct asset id for a file.
209
+ def rails_asset_id(path)
210
+ asset_id = ENV["RAILS_ASSET_ID"]
211
+ return asset_id if asset_id
212
+ File.exists?(path) ? File.mtime(path).to_i.to_s : ''
213
+ end
214
+
215
+ # An asset is valid for embedding if it exists, is less than 32K, and is
216
+ # stored somewhere inside of a folder named "embed". IE does not support
217
+ # Data-URIs larger than 32K, and you probably shouldn't be embedding assets
218
+ # that large in any case. Because we need to check the base64 length here,
219
+ # save it so that we don't have to compute it again later.
220
+ def embeddable?(asset_path, variant)
221
+ font = EMBED_FONTS.include?(asset_path.extname)
222
+ return false unless variant
223
+ return false unless asset_path.to_s.match(EMBEDDABLE) && asset_path.exist?
224
+ return false unless EMBED_EXTS.include?(asset_path.extname)
225
+ return false unless font || encoded_contents(asset_path).length < MAX_IMAGE_SIZE
226
+ return false if font && variant == :mhtml
227
+ return true
228
+ end
229
+
230
+ # Return the Base64-encoded contents of an asset on a single line.
231
+ def encoded_contents(asset_path)
232
+ return @asset_contents[asset_path] if @asset_contents[asset_path]
233
+ data = read_binary_file(asset_path)
234
+ @asset_contents[asset_path] = Base64.encode64(data).gsub(/\n/, '')
235
+ end
236
+
237
+ # Grab the mime-type of an asset, by filename.
238
+ def mime_type(asset_path)
239
+ EMBED_MIME_TYPES[File.extname(asset_path)]
240
+ end
241
+
242
+ # Concatenate together a list of asset files.
243
+ def concatenate(paths)
244
+ [paths].flatten.map {|p| read_binary_file(p) }.join("\n")
245
+ end
246
+
247
+ # `File.read`, but in "binary" mode.
248
+ def read_binary_file(path)
249
+ File.open(path, 'rb:UTF-8') {|f| f.read }
250
+ end
251
+ end
252
+
253
+ end
@@ -0,0 +1,97 @@
1
+ require 'action_controller'
2
+
3
+ module Jammit
4
+
5
+ # The JammitController is added to your Rails application when the Gem is
6
+ # loaded. It takes responsibility for /assets, and dynamically packages any
7
+ # missing or uncached asset packages.
8
+ class Controller < ActionController::Base
9
+
10
+ VALID_FORMATS = [:css, :js]
11
+
12
+ SUFFIX_STRIPPER = /-(datauri|mhtml)\Z/
13
+
14
+ NOT_FOUND_PATH = "#{Jammit.public_root}/404.html"
15
+
16
+ # The "package" action receives all requests for asset packages that haven't
17
+ # yet been cached. The package will be built, cached, and gzipped.
18
+ def package
19
+ parse_request
20
+ template_ext = Jammit.template_extension.to_sym
21
+ case @extension
22
+ when :js
23
+ render :js => (@contents = Jammit.packager.pack_javascripts(@package))
24
+ when template_ext
25
+ render :js => (@contents = Jammit.packager.pack_templates(@package))
26
+ when :css
27
+ render :text => generate_stylesheets, :content_type => 'text/css'
28
+ end
29
+ cache_package if perform_caching && (@extension != template_ext)
30
+ rescue Jammit::PackageNotFound
31
+ package_not_found
32
+ end
33
+
34
+
35
+ private
36
+
37
+ # Tells the Jammit::Packager to cache and gzip an asset package. We can't
38
+ # just use the built-in "cache_page" because we need to ensure that
39
+ # the timestamp that ends up in the MHTML is also on the cached file.
40
+ def cache_package
41
+ dir = File.join(page_cache_directory, Jammit.package_path)
42
+ Jammit.packager.cache(@package, @extension, @contents, dir, @variant, @mtime)
43
+ end
44
+
45
+ # Generate the complete, timestamped, MHTML url -- if we're rendering a
46
+ # dynamic MHTML package, we'll need to put one URL in the response, and a
47
+ # different one into the cached package.
48
+ def prefix_url(path)
49
+ host = request.port == 80 ? request.host : request.host_with_port
50
+ "#{request.protocol}#{host}#{path}"
51
+ end
52
+
53
+ # If we're generating MHTML/CSS, return a stylesheet with the absolute
54
+ # request URL to the client, and cache a version with the timestamped cache
55
+ # URL swapped in.
56
+ def generate_stylesheets
57
+ return @contents = Jammit.packager.pack_stylesheets(@package, @variant) unless @variant == :mhtml
58
+ @mtime = Time.now
59
+ request_url = prefix_url(request.fullpath)
60
+ cached_url = prefix_url(Jammit.asset_url(@package, @extension, @variant, @mtime))
61
+ css = Jammit.packager.pack_stylesheets(@package, @variant, request_url)
62
+ @contents = css.gsub(request_url, cached_url) if perform_caching
63
+ css
64
+ end
65
+
66
+ # Extracts the package name, extension (:css, :js), and variant (:datauri,
67
+ # :mhtml) from the incoming URL.
68
+ def parse_request
69
+ pack = params[:package]
70
+ @extension = params[:extension].to_sym
71
+ raise PackageNotFound unless (VALID_FORMATS + [Jammit.template_extension.to_sym]).include?(@extension)
72
+ if Jammit.embed_assets
73
+ suffix_match = pack.match(SUFFIX_STRIPPER)
74
+ @variant = Jammit.embed_assets && suffix_match && suffix_match[1].to_sym
75
+ pack.sub!(SUFFIX_STRIPPER, '')
76
+ end
77
+ @package = pack.to_sym
78
+ end
79
+
80
+ # Render the 404 page, if one exists, for any packages that don't.
81
+ def package_not_found
82
+ return render(:file => NOT_FOUND_PATH, :status => 404) if File.exists?(NOT_FOUND_PATH)
83
+ render :text => "<h1>404: \"#{@package}\" asset package not found.</h1>", :status => 404
84
+ end
85
+
86
+ end
87
+
88
+ end
89
+
90
+ # Make the Jammit::Controller available to Rails as a top-level controller.
91
+ ::JammitController = Jammit::Controller
92
+
93
+ if defined?(Rails) && Rails.env.development?
94
+ ActionController::Base.class_eval do
95
+ append_before_filter { Jammit.reload! }
96
+ end
97
+ end
@@ -0,0 +1,42 @@
1
+ # Standard Library Dependencies:
2
+ require 'uri'
3
+ require 'erb'
4
+ require 'zlib'
5
+ require 'yaml'
6
+ require 'base64'
7
+ require 'pathname'
8
+ require 'fileutils'
9
+
10
+ # Include YUI as the default
11
+ require 'yui/compressor'
12
+
13
+ # Try Closure.
14
+ begin
15
+ require 'closure-compiler'
16
+ rescue LoadError
17
+ Jammit.compressors.delete :closure
18
+ end
19
+
20
+ # Try Uglifier.
21
+ begin
22
+ require 'uglifier'
23
+ rescue LoadError
24
+ Jammit.compressors.delete :uglifier
25
+ end
26
+
27
+ # Load initial configuration before the rest of Jammit.
28
+ Jammit.load_configuration(Jammit::DEFAULT_CONFIG_PATH, true) if defined?(Rails)
29
+
30
+ # Jammit Core:
31
+ require 'jammit/uglifier' if Jammit.compressors.include? :uglifier
32
+ require 'jammit/compressor'
33
+ require 'jammit/packager'
34
+
35
+ # Jammit Rails Integration:
36
+ if defined?(Rails)
37
+ require 'jammit/controller'
38
+ require 'jammit/helper'
39
+ require 'jammit/railtie'
40
+ require 'jammit/routes'
41
+ end
42
+
@@ -0,0 +1,88 @@
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)]><!-->" unless defined?(DATA_URI_START)
10
+ DATA_URI_END = "<!--<![endif]-->" unless defined?(DATA_URI_END)
11
+ MHTML_START = "<!--[if lte IE 7]>" unless defined?(MHTML_START)
12
+ MHTML_END = "<![endif]-->" unless defined?(MHTML_END)
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 html_safe(individual_stylesheets(packages, options)) unless should_package?
20
+ disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
21
+ return html_safe(packaged_stylesheets(packages, options)) if disabled || !Jammit.embed_assets
22
+ return html_safe(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
+ options = packages.extract_options!
29
+ html_safe packages.map {|pack|
30
+ should_package? ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
31
+ }.flatten.map {|pack|
32
+ javascript_include_tag pack, options
33
+ }.join("\n")
34
+ end
35
+
36
+ # Writes out the URL to the concatenated and compiled JST file -- we always
37
+ # have to pre-process it, even in development.
38
+ def include_templates(*packages)
39
+ raise DeprecationError, "Jammit 0.5+ no longer supports separate packages for templates.\nYou can include your JST alongside your JS, and use include_javascripts."
40
+ end
41
+
42
+
43
+ private
44
+
45
+ def should_package?
46
+ Jammit.package_assets && !(Jammit.allow_debugging && params[:debug_assets])
47
+ end
48
+
49
+ def html_safe(string)
50
+ string.respond_to?(:html_safe) ? string.html_safe : string
51
+ end
52
+
53
+ # HTML tags, in order, for all of the individual stylesheets.
54
+ def individual_stylesheets(packages, options)
55
+ tags_with_options(packages, options) {|p| Jammit.packager.individual_urls(p.to_sym, :css) }
56
+ end
57
+
58
+ # HTML tags for the stylesheet packages.
59
+ def packaged_stylesheets(packages, options)
60
+ tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css) }
61
+ end
62
+
63
+ # HTML tags for the 'datauri', and 'mhtml' versions of the packaged
64
+ # stylesheets, using conditional comments to load the correct variant.
65
+ def embedded_image_stylesheets(packages, options)
66
+ datauri_tags = tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :datauri) }
67
+ ie_tags = Jammit.mhtml_enabled ?
68
+ tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :mhtml) } :
69
+ packaged_stylesheets(packages, options)
70
+ [DATA_URI_START, datauri_tags, DATA_URI_END, MHTML_START, ie_tags, MHTML_END].join("\n")
71
+ end
72
+
73
+ # Generate the stylesheet tags for a batch of packages, with options, by
74
+ # yielding each package to a block.
75
+ def tags_with_options(packages, options)
76
+ packages.dup.map {|package|
77
+ yield package
78
+ }.flatten.map {|package|
79
+ stylesheet_link_tag package, options
80
+ }.join("\n")
81
+ end
82
+
83
+ end
84
+
85
+ end
86
+
87
+ # Include the Jammit asset helpers in all views, a-la ApplicationHelper.
88
+ ::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(/\\/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;};
@@ -0,0 +1,173 @@
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
+
10
+ # Set force to false to allow packages to only be rebuilt when their source
11
+ # files have changed since the last time their package was built.
12
+ attr_accessor :force, :package_names
13
+
14
+ # Creating a new Packager will rebuild the list of assets from the
15
+ # Jammit.configuration. When assets.yml is being changed on the fly,
16
+ # create a new Packager.
17
+ def initialize
18
+ # In Rails, the difference between a path and an asset URL is "public".
19
+ @path_diff = Jammit.public_root.sub(ASSET_ROOT, '')
20
+ @path_to_url = /\A#{Regexp.escape(ASSET_ROOT)}(\/?#{Regexp.escape(@path_diff)})?/
21
+
22
+ @compressor = Compressor.new
23
+ @force = false
24
+ @package_names = nil
25
+ @config = {
26
+ :css => (Jammit.configuration[:stylesheets] || {}),
27
+ :js => (Jammit.configuration[:javascripts] || {})
28
+ }
29
+ @packages = {
30
+ :css => create_packages(@config[:css]),
31
+ :js => create_packages(@config[:js])
32
+ }
33
+ end
34
+
35
+ # Ask the packager to precache all defined assets, along with their gzip'd
36
+ # versions. In order to prebuild the MHTML stylesheets, we need to know the
37
+ # base_url, because IE only supports MHTML with absolute references.
38
+ # Unless forced, will only rebuild assets whose source files have been
39
+ # changed since their last package build.
40
+ def precache_all(output_dir=nil, base_url=nil)
41
+ output_dir ||= File.join(Jammit.public_root, Jammit.package_path)
42
+ cacheable(:js, output_dir).each {|p| cache(p, 'js', pack_javascripts(p), output_dir) }
43
+ cacheable(:css, output_dir).each do |p|
44
+ cache(p, 'css', pack_stylesheets(p), output_dir)
45
+ if Jammit.embed_assets
46
+ cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
47
+ if Jammit.mhtml_enabled
48
+ raise MissingConfiguration, "A --base-url option is required in order to generate MHTML." unless base_url
49
+ mtime = latest_mtime package_for(p, :css)[:paths]
50
+ asset_url = "#{base_url}#{Jammit.asset_url(p, :css, :mhtml, mtime)}"
51
+ cache(p, 'css', pack_stylesheets(p, :mhtml, asset_url), output_dir, :mhtml, mtime)
52
+ end
53
+ end
54
+ end
55
+ end
56
+
57
+ # Caches a single prebuilt asset package and gzips it at the highest
58
+ # compression level. Ensures that the modification time of both both
59
+ # variants is identical, for web server caching modules, as well as MHTML.
60
+ def cache(package, extension, contents, output_dir, suffix=nil, mtime=nil)
61
+ FileUtils.mkdir_p(output_dir) unless File.exists?(output_dir)
62
+ raise OutputNotWritable, "Jammit doesn't have permission to write to \"#{output_dir}\"" unless File.writable?(output_dir)
63
+ mtime ||= latest_mtime package_for(package, extension.to_sym)[:paths]
64
+ files = []
65
+ files << file_name = File.join(output_dir, Jammit.filename(package, extension, suffix))
66
+ File.open(file_name, 'wb+') {|f| f.write(contents) }
67
+ if Jammit.gzip_assets
68
+ files << zip_name = "#{file_name}.gz"
69
+ Zlib::GzipWriter.open(zip_name, Zlib::BEST_COMPRESSION) {|f| f.write(contents) }
70
+ end
71
+ File.utime(mtime, mtime, *files)
72
+ end
73
+
74
+ # Get the list of individual assets for a package.
75
+ def individual_urls(package, extension)
76
+ package_for(package, extension)[:urls]
77
+ end
78
+
79
+ # Return the compressed contents of a stylesheet package.
80
+ def pack_stylesheets(package, variant=nil, asset_url=nil)
81
+ @compressor.compress_css(package_for(package, :css)[:paths], variant, asset_url)
82
+ end
83
+
84
+ # Return the compressed contents of a javascript package.
85
+ def pack_javascripts(package)
86
+ @compressor.compress_js(package_for(package, :js)[:paths])
87
+ end
88
+
89
+ # Return the compiled contents of a JST package.
90
+ def pack_templates(package)
91
+ @compressor.compile_jst(package_for(package, :js)[:paths])
92
+ end
93
+
94
+ private
95
+
96
+ # Look up a package asset list by name, raising an exception if the
97
+ # package has gone missing.
98
+ def package_for(package, extension)
99
+ pack = @packages[extension] && @packages[extension][package]
100
+ pack || not_found(package, extension)
101
+ end
102
+
103
+ # Absolute globs are absolute -- relative globs are relative to ASSET_ROOT.
104
+ # Print a warning if no files were found that match the glob.
105
+ def glob_files(glob)
106
+ absolute = Pathname.new(glob).absolute?
107
+ paths = Dir[absolute ? glob : File.join(ASSET_ROOT, glob)].sort
108
+ Jammit.warn("No assets match '#{glob}'") if paths.empty?
109
+ paths
110
+ end
111
+
112
+ # Get the latest mtime of a list of files (plus the config path).
113
+ def latest_mtime(paths)
114
+ paths += [Jammit.config_path]
115
+ paths.map {|p| File.mtime(p) }.max || Time.now
116
+ end
117
+
118
+ # Return a list of all of the packages that should be cached. If "force" is
119
+ # true, this is all of them -- otherwise only the packages that are missing
120
+ # or whose source files have changed since the last package build.
121
+ def cacheable(extension, output_dir)
122
+ names = @packages[extension].keys
123
+ names = names.select {|n| @package_names.include? n } if @package_names
124
+ config_mtime = File.mtime(Jammit.config_path)
125
+ return names if @force
126
+ return names.select do |name|
127
+ pack = package_for(name, extension)
128
+ cached = [Jammit.filename(name, extension)]
129
+ cached.push Jammit.filename(name, extension, :datauri) if Jammit.embed_assets
130
+ cached.push Jammit.filename(name, extension, :mhtml) if Jammit.mhtml_enabled
131
+ cached.map! {|file| File.join(output_dir, file) }
132
+ if cached.any? {|file| !File.exists?(file) }
133
+ true
134
+ else
135
+ since = cached.map {|file| File.mtime(file) }.min
136
+ config_mtime > since || pack[:paths].any? {|src| File.mtime(src) > since }
137
+ end
138
+ end
139
+ end
140
+
141
+ # Compiles the list of assets that goes into each package. Runs an
142
+ # ordered list of Dir.globs, taking the merged unique result.
143
+ # If there are JST files in this package we need to add an extra
144
+ # path for when package_assets is off (e.g. in a dev environment).
145
+ # This package (e.g. /assets/package-name.jst) will never exist as
146
+ # an actual file but will be dynamically generated by Jammit on
147
+ # every request.
148
+ def create_packages(config)
149
+ packages = {}
150
+ return packages if !config
151
+ config.each do |name, globs|
152
+ globs ||= []
153
+ packages[name] = {}
154
+ paths = globs.flatten.uniq.map {|glob| glob_files(glob) }.flatten.uniq
155
+ packages[name][:paths] = paths
156
+ if !paths.grep(Jammit.template_extension_matcher).empty?
157
+ packages[name][:urls] = paths.grep(JS_EXTENSION).map {|path| path.sub(@path_to_url, '') }
158
+ packages[name][:urls] += [Jammit.asset_url(name, Jammit.template_extension)]
159
+ else
160
+ packages[name][:urls] = paths.map {|path| path.sub(@path_to_url, '') }
161
+ end
162
+ end
163
+ packages
164
+ end
165
+
166
+ # Raise a PackageNotFound exception for missing packages...
167
+ def not_found(package, extension)
168
+ raise PackageNotFound, "assets.yml does not contain a \"#{package}\" #{extension.to_s.upcase} package"
169
+ end
170
+
171
+ end
172
+
173
+ end
@@ -0,0 +1,14 @@
1
+ # Rails 3 configuration via Railtie
2
+
3
+ if defined?(Rails::Railtie)
4
+ module Jammit
5
+ class Railtie < Rails::Railtie
6
+
7
+ initializer :jammit_routes do |app|
8
+ # Add a Jammit route for the reloader.
9
+ app.routes_reloader.paths << File.join(File.dirname(__FILE__), "..", "..", "rails", "routes.rb")
10
+ end
11
+
12
+ end
13
+ end
14
+ end
@@ -0,0 +1,23 @@
1
+ module Jammit
2
+
3
+ # Rails 2.x routing module. Rails 3.x routes are in rails/routes.rb.
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',
13
+ :action => 'package',
14
+ :requirements => {
15
+ # A hack to allow extension to include "."
16
+ :extension => /.+/
17
+ }
18
+ }
19
+ end
20
+
21
+ end
22
+
23
+ end
@@ -0,0 +1,3 @@
1
+ class Jammit::Uglifier < ::Uglifier
2
+ alias :compress :compile
3
+ end
@@ -0,0 +1,10 @@
1
+ if defined?(Rails::Application)
2
+ # Rails3 routes
3
+ Rails.application.routes.draw do
4
+ match "/#{Jammit.package_path}/:package.:extension",
5
+ :to => 'jammit#package', :as => :jammit, :constraints => {
6
+ # A hack to allow extension to include "."
7
+ :extension => /.+/
8
+ }
9
+ end
10
+ end
metadata ADDED
@@ -0,0 +1,104 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: alegscogs_jammit
3
+ version: !ruby/object:Gem::Version
4
+ hash: -356544035
5
+ prerelease: 6
6
+ segments:
7
+ - 0
8
+ - 6
9
+ - 3
10
+ - alegscogs
11
+ version: 0.6.3.alegscogs
12
+ platform: ruby
13
+ authors:
14
+ - Jeremy Ashkenas
15
+ - Alex Cox
16
+ autorequire:
17
+ bindir: bin
18
+ cert_chain: []
19
+
20
+ date: 2011-11-16 00:00:00 Z
21
+ dependencies:
22
+ - !ruby/object:Gem::Dependency
23
+ name: yui-compressor
24
+ prerelease: false
25
+ requirement: &id001 !ruby/object:Gem::Requirement
26
+ none: false
27
+ requirements:
28
+ - - ">="
29
+ - !ruby/object:Gem::Version
30
+ hash: 61
31
+ segments:
32
+ - 0
33
+ - 9
34
+ - 3
35
+ version: 0.9.3
36
+ type: :runtime
37
+ version_requirements: *id001
38
+ 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\n This is a fork with a tiny patch allowing you to pass options to the include_\n javascripts helper.\n"
39
+ email: alegscogs@gmail.com
40
+ executables:
41
+ - jammit
42
+ extensions: []
43
+
44
+ extra_rdoc_files:
45
+ - README
46
+ files:
47
+ - lib/jammit/command_line.rb
48
+ - lib/jammit/compressor.rb
49
+ - lib/jammit/controller.rb
50
+ - lib/jammit/dependencies.rb
51
+ - lib/jammit/helper.rb
52
+ - lib/jammit/jst.js
53
+ - lib/jammit/packager.rb
54
+ - lib/jammit/railtie.rb
55
+ - lib/jammit/routes.rb
56
+ - lib/jammit/uglifier.rb
57
+ - lib/jammit.rb
58
+ - bin/jammit
59
+ - rails/routes.rb
60
+ - LICENSE
61
+ - README
62
+ homepage: http://github.com/alegscogs/jammit/
63
+ licenses: []
64
+
65
+ post_install_message:
66
+ rdoc_options:
67
+ - --title
68
+ - Jammit
69
+ - --exclude
70
+ - test
71
+ - --main
72
+ - README
73
+ - --all
74
+ require_paths:
75
+ - lib
76
+ required_ruby_version: !ruby/object:Gem::Requirement
77
+ none: false
78
+ requirements:
79
+ - - ">="
80
+ - !ruby/object:Gem::Version
81
+ hash: 3
82
+ segments:
83
+ - 0
84
+ version: "0"
85
+ required_rubygems_version: !ruby/object:Gem::Requirement
86
+ none: false
87
+ requirements:
88
+ - - ">"
89
+ - !ruby/object:Gem::Version
90
+ hash: 25
91
+ segments:
92
+ - 1
93
+ - 3
94
+ - 1
95
+ version: 1.3.1
96
+ requirements: []
97
+
98
+ rubyforge_project: alegscogs_jammit
99
+ rubygems_version: 1.8.10
100
+ signing_key:
101
+ specification_version: 3
102
+ summary: Industrial Strength Asset Packaging for Rails
103
+ test_files: []
104
+