[DRE-commits] [diaspora] 02/06: embed sprockets 2.12.4, see #810162
Praveen Arimbrathodiyil
praveen at moszumanska.debian.org
Thu Jan 7 07:09:42 UTC 2016
This is an automated email from the git hooks/post-receive script.
praveen pushed a commit to branch master
in repository diaspora.
commit e90babeb1a0bf0efa1209ba47911acb41d226478
Author: Praveen Arimbrathodiyil <praveen at debian.org>
Date: Thu Jan 7 12:02:37 2016 +0530
embed sprockets 2.12.4, see #810162
---
debian/gems-compat/sprockets-2.12.4/LICENSE | 21 +
debian/gems-compat/sprockets-2.12.4/README.md | 536 +++++++++++++++++++++
debian/gems-compat/sprockets-2.12.4/bin/sprockets | 88 ++++
.../sprockets-2.12.4/lib/rake/sprocketstask.rb | 151 ++++++
.../gems-compat/sprockets-2.12.4/lib/sprockets.rb | 108 +++++
.../sprockets-2.12.4/lib/sprockets/asset.rb | 269 +++++++++++
.../lib/sprockets/asset_attributes.rb | 137 ++++++
.../sprockets-2.12.4/lib/sprockets/base.rb | 447 +++++++++++++++++
.../lib/sprockets/bundled_asset.rb | 78 +++
.../lib/sprockets/cache/file_store.rb | 32 ++
.../sprockets-2.12.4/lib/sprockets/caching.rb | 96 ++++
.../lib/sprockets/charset_normalizer.rb | 41 ++
.../lib/sprockets/closure_compressor.rb | 22 +
.../sprockets-2.12.4/lib/sprockets/compressing.rb | 73 +++
.../sprockets-2.12.4/lib/sprockets/context.rb | 289 +++++++++++
.../lib/sprockets/directive_processor.rb | 408 ++++++++++++++++
.../sprockets-2.12.4/lib/sprockets/eco_template.rb | 38 ++
.../sprockets-2.12.4/lib/sprockets/ejs_template.rb | 37 ++
.../sprockets-2.12.4/lib/sprockets/engines.rb | 74 +++
.../sprockets-2.12.4/lib/sprockets/environment.rb | 88 ++++
.../sprockets-2.12.4/lib/sprockets/errors.rb | 20 +
.../sprockets-2.12.4/lib/sprockets/index.rb | 100 ++++
.../lib/sprockets/jst_processor.rb | 29 ++
.../sprockets-2.12.4/lib/sprockets/manifest.rb | 261 ++++++++++
.../sprockets-2.12.4/lib/sprockets/mime.rb | 49 ++
.../sprockets-2.12.4/lib/sprockets/paths.rb | 58 +++
.../lib/sprockets/processed_asset.rb | 152 ++++++
.../sprockets-2.12.4/lib/sprockets/processing.rb | 206 ++++++++
.../sprockets-2.12.4/lib/sprockets/processor.rb | 32 ++
.../lib/sprockets/safety_colons.rb | 28 ++
.../lib/sprockets/sass_cache_store.rb | 29 ++
.../lib/sprockets/sass_compressor.rb | 27 ++
.../lib/sprockets/sass_functions.rb | 70 +++
.../lib/sprockets/sass_importer.rb | 30 ++
.../lib/sprockets/sass_template.rb | 66 +++
.../lib/sprockets/scss_template.rb | 13 +
.../sprockets-2.12.4/lib/sprockets/server.rb | 247 ++++++++++
.../sprockets-2.12.4/lib/sprockets/static_asset.rb | 60 +++
.../lib/sprockets/uglifier_compressor.rb | 29 ++
.../sprockets-2.12.4/lib/sprockets/utils.rb | 69 +++
.../sprockets-2.12.4/lib/sprockets/version.rb | 3 +
.../lib/sprockets/yui_compressor.rb | 27 ++
debian/gems-compat/sprockets-2.12.4/metadata.yml | 320 ++++++++++++
43 files changed, 4958 insertions(+)
diff --git a/debian/gems-compat/sprockets-2.12.4/LICENSE b/debian/gems-compat/sprockets-2.12.4/LICENSE
new file mode 100644
index 0000000..7476999
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) 2011 Sam Stephenson
+Copyright (c) 2011 Joshua Peek
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/debian/gems-compat/sprockets-2.12.4/README.md b/debian/gems-compat/sprockets-2.12.4/README.md
new file mode 100644
index 0000000..0d244db
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/README.md
@@ -0,0 +1,536 @@
+# Sprockets: Rack-based asset packaging
+
+Sprockets is a Ruby library for compiling and serving web assets.
+It features declarative dependency management for JavaScript and CSS
+assets, as well as a powerful preprocessor pipeline that allows you to
+write assets in languages like CoffeeScript, Sass, SCSS and LESS.
+
+# Installation #
+
+Install Sprockets from RubyGems:
+
+ $ gem install sprockets
+
+Or include it in your project's `Gemfile` with Bundler:
+
+ gem 'sprockets', '~> 2.0'
+
+# Understanding the Sprockets Environment #
+
+You'll need an instance of the `Sprockets::Environment` class to
+access and serve assets from your application. Under Rails 3.1 and
+later, `YourApp::Application.assets` is a preconfigured
+`Sprockets::Environment` instance. For Rack-based applications, create
+an instance in `config.ru`.
+
+The Sprockets `Environment` has methods for retrieving and serving
+assets, manipulating the load path, and registering processors. It is
+also a Rack application that can be mounted at a URL to serve assets
+over HTTP.
+
+## The Load Path ##
+
+The *load path* is an ordered list of directories that Sprockets uses
+to search for assets.
+
+In the simplest case, a Sprockets environment's load path will consist
+of a single directory containing your application's asset source
+files. When mounted, the environment will serve assets from this
+directory as if they were static files in your public root.
+
+The power of the load path is that it lets you organize your source
+files into multiple directories -- even directories that live outside
+your application -- and combine those directories into a single
+virtual filesystem. That means you can easily bundle JavaScript, CSS
+and images into a Ruby library and import them into your application.
+
+### Manipulating the Load Path ###
+
+To add a directory to your environment's load path, use the
+`append_path` and `prepend_path` methods. Directories at the beginning
+of the load path have precedence over subsequent directories.
+
+ environment = Sprockets::Environment.new
+ environment.append_path 'app/assets/javascripts'
+ environment.append_path 'lib/assets/javascripts'
+ environment.append_path 'vendor/assets/jquery'
+
+In general, you should append to the path by default and reserve
+prepending for cases where you need to override existing assets.
+
+## Accessing Assets ##
+
+Once you've set up your environment's load path, you can mount the
+environment as a Rack server and request assets via HTTP. You can also
+access assets programmatically from within your application.
+
+### Logical Paths ###
+
+Assets in Sprockets are always referenced by their *logical path*.
+
+The logical path is the path of the asset source file relative to its
+containing directory in the load path. For example, if your load path
+contains the directory `app/assets/javascripts`:
+
+<table>
+ <tr>
+ <th>Asset source file</th>
+ <th>Logical path</th>
+ </tr>
+ <tr>
+ <td>app/assets/javascripts/application.js</td>
+ <td>application.js</td>
+ </tr>
+ <tr>
+ <td>app/assets/javascripts/models/project.js</td>
+ <td>models/project.js</td>
+ </tr>
+</table>
+
+In this way, all directories in the load path are merged to create a
+virtual filesystem whose entries are logical paths.
+
+### Serving Assets Over HTTP ###
+
+When you mount an environment, all of its assets are accessible as
+logical paths underneath the *mount point*. For example, if you mount
+your environment at `/assets` and request the URL
+`/assets/application.js`, Sprockets will search your load path for the
+file named `application.js` and serve it.
+
+Under Rails 3.1 and later, your Sprockets environment is automatically
+mounted at `/assets`. If you are using Sprockets with a Rack
+application, you will need to mount the environment yourself. A good
+way to do this is with the `map` method in `config.ru`:
+
+ require 'sprockets'
+ map '/assets' do
+ environment = Sprockets::Environment.new
+ environment.append_path 'app/assets/javascripts'
+ environment.append_path 'app/assets/stylesheets'
+ run environment
+ end
+
+ map '/' do
+ run YourRackApp
+ end
+
+### Accessing Assets Programmatically ###
+
+You can use the `find_asset` method (aliased as `[]`) to retrieve an
+asset from a Sprockets environment. Pass it a logical path and you'll
+get a `Sprockets::BundledAsset` instance back:
+
+ environment['application.js']
+ # => #<Sprockets::BundledAsset ...>
+
+Call `to_s` on the resulting asset to access its contents, `length` to
+get its length in bytes, `mtime` to query its last-modified time, and
+`pathname` to get its full path on the filesystem.
+
+# Using Engines #
+
+Asset source files can be written in another language, like SCSS or
+CoffeeScript, and automatically compiled to CSS or JavaScript by
+Sprockets. Compilers for these languages are called *engines*.
+
+Engines are specified by additional extensions on the asset source
+filename. For example, a CSS file written in SCSS might have the name
+`layout.css.scss`, while a JavaScript file written in CoffeeScript
+might have the name `dialog.js.coffee`.
+
+## Styling with Sass and SCSS ##
+
+[Sass](http://sass-lang.com/) is a language that compiles to CSS and
+adds features like nested rules, variables, mixins and selector
+inheritance.
+
+If the `sass` gem is available to your application, you can use Sass
+to write CSS assets in Sprockets.
+
+Sprockets supports both Sass syntaxes. For the original
+whitespace-sensitive syntax, use the extension `.css.sass`. For the
+new SCSS syntax, use the extension `.css.scss`.
+
+## Styling with LESS ##
+
+[LESS](http://lesscss.org/) extends CSS with dynamic behavior such as
+variables, mixins, operations and functions.
+
+If the `less` gem is available to your application, you can use LESS
+to write CSS assets in Sprockets. Note that the LESS compiler is
+written in JavaScript and the `less` gem (on MRI) uses `therubyracer`
+which embeds the V8 JavaScript runtime in Ruby, while on JRuby you're
+going to need `therubyrhino` gem installed.
+
+To write CSS assets with LESS, use the extension `.css.less`.
+
+## Scripting with CoffeeScript ##
+
+[CoffeeScript](http://jashkenas.github.com/coffee-script/) is a
+language that compiles to the "good parts" of JavaScript, featuring a
+cleaner syntax with array comprehensions, classes, and function
+binding.
+
+If the `coffee-script` gem is available to your application, you can
+use CoffeeScript to write JavaScript assets in Sprockets. Note that
+the CoffeeScript compiler is written in JavaScript, and you will need
+an [ExecJS](https://github.com/sstephenson/execjs)-supported runtime
+on your system to invoke it.
+
+To write JavaScript assets with CoffeeScript, use the extension
+`.js.coffee`.
+
+## JavaScript Templating with EJS and Eco ##
+
+Sprockets supports *JavaScript templates* for client-side rendering of
+strings or markup. JavaScript templates have the special format
+extension `.jst` and are compiled to JavaScript functions.
+
+When loaded, a JavaScript template function can be accessed by its
+logical path as a property on the global `JST` object. Invoke a
+template function to render the template as a string. The resulting
+string can then be inserted into the DOM.
+
+ <!-- templates/hello.jst.ejs -->
+ <div>Hello, <span><%= name %></span>!</div>
+
+ // application.js
+ //= require templates/hello
+ $("#hello").html(JST["templates/hello"]({ name: "Sam" }));
+
+Sprockets supports two JavaScript template languages:
+[EJS](https://github.com/sstephenson/ruby-ejs), for embedded
+JavaScript, and [Eco](https://github.com/sstephenson/ruby-eco), for
+embedded CoffeeScript. Both languages use the familiar `<% … %>`
+syntax for embedding logic in templates.
+
+If the `ejs` gem is available to your application, you can use EJS
+templates in Sprockets. EJS templates have the extension `.jst.ejs`.
+
+If the `eco` gem is available to your application, you can use [Eco
+templates](https://github.com/sstephenson/eco) in Sprockets. Eco
+templates have the extension `.jst.eco`. Note that the `eco` gem
+depends on the CoffeeScript compiler, so the same caveats apply as
+outlined above for the CoffeeScript engine.
+
+## Invoking Ruby with ERB ##
+
+Sprockets provides an ERB engine for preprocessing assets using
+embedded Ruby code. Append `.erb` to a CSS or JavaScript asset's
+filename to enable the ERB engine.
+
+**Note**: Sprockets processes multiple engine extensions in order from
+ right to left, so you can use multiple engines with a single
+ asset. For example, to have a CoffeeScript asset that is first
+ preprocessed with ERB, use the extension `.js.coffee.erb`.
+
+Ruby code embedded in an asset is evaluated in the context of a
+`Sprockets::Context` instance for the given asset. Common uses for ERB
+include:
+
+- embedding another asset as a Base64-encoded `data:` URI with the
+ `asset_data_uri` helper
+- inserting the URL to another asset, such as with the `asset_path`
+ helper provided by the Sprockets Rails plugin
+- embedding other application resources, such as a localized string
+ database, in a JavaScript asset via JSON
+- embedding version constants loaded from another file
+
+See the [Helper Methods](#FIXME) section for more information about
+interacting with `Sprockets::Context` instances via ERB.
+
+### String Interpolation Syntax ###
+
+If you need access to Ruby from an asset but cannot use ERB's `<% …
+%>` syntax, Sprockets also supports Ruby string interpolation syntax
+(`#{ … }`) with the `.str` engine extension.
+
+# Managing and Bundling Dependencies #
+
+You can create *asset bundles* -- ordered concatenations of asset
+source files -- by specifying dependencies in a special comment syntax
+at the top of each source file.
+
+Sprockets reads these comments, called *directives*, and processes
+them to recursively build a dependency graph. When you request an
+asset with dependencies, the dependencies will be included in order at
+the top of the file.
+
+## The Directive Processor ##
+
+Sprockets runs the *directive processor* on each CSS and JavaScript
+source file. The directive processor scans for comment lines beginning
+with `=` in comment blocks at the top of the file.
+
+ //= require jquery
+ //= require jquery-ui
+ //= require backbone
+ //= require_tree .
+
+The first word immediately following `=` specifies the directive
+name. Any words following the directive name are treated as
+arguments. Arguments may be placed in single or double quotes if they
+contain spaces, similar to commands in the Unix shell.
+
+**Note**: Non-directive comment lines will be preserved in the final
+ asset, but directive comments are stripped after
+ processing. Sprockets will not look for directives in comment blocks
+ that occur after the first line of code.
+
+### Supported Comment Types ###
+
+The directive processor understands comment blocks in three formats:
+
+ /* Multi-line comment blocks (CSS, SCSS, JavaScript)
+ *= require foo
+ */
+
+ // Single-line comment blocks (SCSS, JavaScript)
+ //= require foo
+
+ # Single-line comment blocks (CoffeeScript)
+ #= require foo
+
+## Sprockets Directives ##
+
+You can use the following directives to declare dependencies in asset
+source files.
+
+For directives that take a *path* argument, you may specify either a
+logical path or a relative path. Relative paths begin with `./` and
+reference files relative to the location of the current file.
+
+### The `require` Directive ###
+
+`require` *path* inserts the contents of the asset source file
+specified by *path*. If the file is required multiple times, it will
+appear in the bundle only once.
+
+### The `include` Directive ###
+
+`include` *path* works like `require`, but inserts the contents of the
+specified source file even if it has already been included or
+required.
+
+### The `require_directory` Directive ###
+
+`require_directory` *path* requires all source files of the same
+format in the directory specified by *path*. Files are required in
+alphabetical order.
+
+### The `require_tree` Directive ###
+
+`require_tree` *path* works like `require_directory`, but operates
+recursively to require all files in all subdirectories of the
+directory specified by *path*.
+
+### The `require_self` Directive ###
+
+`require_self` tells Sprockets to insert the body of the current
+source file before any subsequent `require` or `include` directives.
+
+### The `depend_on` Directive ###
+
+`depend_on` *path* declares a dependency on the given *path* without
+including it in the bundle. This is useful when you need to expire an
+asset's cache in response to a change in another file.
+
+### The `depend_on_asset` Directive ###
+
+`depend_on_asset` *path* works like `depend_on`, but operates
+recursively reading the the file and following the directives found.
+
+### The `stub` Directive ###
+
+`stub` *path* allows dependency to be excluded from the asset bundle.
+The *path* must be a valid asset and may or may not already be part
+of the bundle. Once stubbed, it is blacklisted and can't be brought
+back by any other `require`.
+
+# Development #
+
+## Contributing ##
+
+The Sprockets source code is [hosted on
+GitHub](https://github.com/sstephenson/sprockets). You can check out a
+copy of the latest code using Git:
+
+ $ git clone https://github.com/sstephenson/sprockets.git
+
+If you've found a bug or have a question, please open an issue on the
+[Sprockets issue
+tracker](https://github.com/sstephenson/sprockets/issues). Or, clone
+the Sprockets repository, write a failing test case, fix the bug and
+submit a pull request.
+
+## Version History ##
+
+**2.12.3** (October 28, 2014)
+
+* Security: Fix directory traversal bug in development mode server.
+
+**2.12.2** (September 5, 2014)
+
+* Ensure internal asset lookups calls are still restricted to load paths within
+ asset compiles. Though, you should not depend on internal asset resolves to be
+ completely restricted for security reasons. Assets themselves should be
+ considered full scripting environments with filesystem access.
+
+**2.12.1** (April 17, 2014)
+
+* Fix making manifest target directory when its different than the output directory.
+
+**2.12.0** (March 13, 2014)
+
+* Avoid context reference in SassImporter hack so its Marshallable. Fixes
+ issues with Sass 3.3.x.
+
+**2.11.0** (February 19, 2014)
+
+* Support for `.bower.json`
+
+**2.10.0** (May 24, 2013)
+
+* Support for `bower.json`
+
+**2.9.3** (April 20, 2013)
+
+* Fixed sass caching bug
+
+**2.9.2** (April 8, 2013)
+
+* Improve file freshness check performance
+* Directive processor encoding fixes
+
+**2.9.1** (April 6, 2013)
+
+* Support for Uglifier 2.x
+
+**2.9.0** (February 25, 2013)
+
+* Write out gzipped variants of bundled assets.
+
+**2.8.2** (December 10, 2012)
+
+* Fixed top level Sass constant references
+* Fixed manifest logger when environment is disabled
+
+**2.8.1** (October 31, 2012)
+
+* Fixed Sass importer bug
+
+**2.8.0** (October 16, 2012)
+
+* Allow manifest location to be seperated from output directory
+* Pass logical path and absolute path to each_logical_path iterator
+
+**2.7.0** (October 10, 2012)
+
+* Added --css-compressor and --js-compressor command line flags
+* Added css/js compressor shorthand
+* Change default manifest.json filename to be a randomized manifest-16HEXBYTES.json
+* Allow nil environment to be passed to manifest
+* Allow manifest instance to be set on rake task
+
+**2.6.0** (September 19, 2012)
+
+* Added bower component.json require support
+
+**2.5.0** (September 4, 2012)
+
+* Fixed Ruby 2.0 RegExp warning
+* Provide stubbed implementation of context *_path helpers
+* Add SassCompressor
+
+**2.4.5** (July 10, 2012)
+
+* Tweaked some logger levels
+
+**2.4.4** (July 2, 2012)
+
+* Canonicalize logical path extensions
+* Check absolute paths passed to depend_on
+
+**2.4.3** (May 16, 2012)
+
+* Exposed :sprockets in sass options
+* Include dependency paths in asset mtime
+
+**2.4.2** (May 7, 2012)
+
+* Fixed MultiJson feature detect
+
+**2.4.1** (April 26, 2012)
+
+* Fixed MultiJson API change
+* Fixed gzip mtime
+
+**2.4.0** (March 27, 2012)
+
+* Added global path registry
+* Added global processor registry
+
+**2.3.2** (March 26, 2012)
+
+* Fix Context#logical_path with dots
+
+**2.3.1** (February 11, 2012)
+
+* Added bytesize to manifest
+* Added Asset#bytesize alias
+* Security: Check path for forbidden access after unescaping
+
+**2.3.0** (January 16, 2012)
+
+* Added special Sass importer that automatically tracks any `@import`ed files.
+
+**2.2.0** (January 10, 2012)
+
+* Added `sprockets` command line utility.
+* Added rake/sprocketstask.
+* Added json manifest log of compiled assets.
+* Added `stub` directive that allows you to exclude files from the bundle.
+* Added per environment external encoding (Environment#default_external_encoding). Defaults to UTF-8. Fixes issues where LANG is not set correctly and Rubys default external is set to ASCII.
+
+**2.1.2** (November 20, 2011)
+
+* Disabled If-Modified-Since server checks. Fixes some browser caching issues when serving the asset body only. If-None-Match caching is sufficent.
+
+**2.1.1** (November 18, 2011)
+
+* Fix windows absolute path check bug.
+
+**2.1.0** (November 11, 2011)
+
+* Directive comment lines are now turned into empty lines instead of removed. This way line numbers in
+ CoffeeScript syntax errors are correct.
+* Performance and caching bug fixes.
+
+**2.0.3** (October 17, 2011)
+
+* Detect format extensions from right to left.
+* Make JST namespace configurable.
+
+**2.0.2** (October 4, 2011)
+
+* Fixed loading stale cache from bundler gems.
+
+**2.0.1** (September 30, 2011)
+
+* Fixed bug with fingerprinting file names with multiple dots.
+* Decode URIs as default internal.
+* Fix symlinked asset directories.
+
+**2.0.0** (August 29, 2011)
+
+* Initial public release.
+
+# License #
+
+Copyright © 2011 Sam Stephenson <<sstephenson at gmail.com>>
+
+Copyright © 2011 Joshua Peek <<josh at joshpeek.com>>
+
+Sprockets is distributed under an MIT-style license. See LICENSE for
+details.
diff --git a/debian/gems-compat/sprockets-2.12.4/bin/sprockets b/debian/gems-compat/sprockets-2.12.4/bin/sprockets
new file mode 100755
index 0000000..a3fb651
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/bin/sprockets
@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'sprockets'
+require 'optparse'
+require 'shellwords'
+
+unless ARGV.delete("--noenv")
+ if File.exist?(path = "./.sprocketsrc")
+ rcflags = Shellwords.split(File.read(path))
+ ARGV.unshift(*rcflags)
+ end
+end
+
+filenames = []
+environment = Sprockets::Environment.new(Dir.pwd)
+manifest = nil
+
+(ENV['SPROCKETS_PATH'] || "").split(File::PATH_SEPARATOR).each do |path|
+ environment.append_path path
+end
+
+OptionParser.new do |opts|
+ opts.summary_width = 28
+ opts.banner = "Usage: sprockets [options] filename [filename ...]"
+
+ def opts.show_usage
+ puts self
+ exit 1
+ end
+
+ opts.on("-r", "--require LIBRARY", "Require the LIBRARY before doing anything") do |lib|
+ require lib
+ end
+
+ opts.on("-I DIRECTORY", "--include=DIRECTORY", "Adds the directory to the Sprockets load path") do |directory|
+ environment.append_path directory
+ end
+
+ opts.on("-o DIRECTORY", "--output=DIRECTORY", "Copy provided assets into DIRECTORY") do |directory|
+ manifest = Sprockets::Manifest.new(environment, directory)
+ end
+
+ opts.on("--css-compressor=COMPRESSOR", "Use CSS compressor") do |compressor|
+ environment.css_compressor = compressor.to_sym
+ end
+
+ opts.on("--js-compressor=COMPRESSOR", "Use JavaScript compressor") do |compressor|
+ environment.js_compressor = compressor.to_sym
+ end
+
+ opts.on("--noenv", "Disables .sprocketsrc file") do
+ end
+
+ opts.on_tail("-h", "--help", "Shows this help message") do
+ opts.show_usage
+ end
+
+ opts.on_tail("-v", "--version", "Shows version") do
+ puts Sprockets::VERSION
+ exit
+ end
+
+ opts.show_usage if ARGV.empty?
+
+ begin
+ opts.order(ARGV) do |filename|
+ filenames << File.expand_path(filename)
+ end
+ rescue OptionParser::ParseError => e
+ opts.warn e.message
+ opts.show_usage
+ end
+end
+
+if environment.paths.empty?
+ warn "No load paths given"
+ warn "Usage: sprockets -Ijavascripts/ filename"
+ exit 1
+end
+
+if manifest
+ manifest.compile(filenames)
+elsif filenames.length == 1
+ puts environment.find_asset(filenames.first).to_s
+else
+ warn "Only one file can be compiled to stdout at a time"
+ exit 1
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/rake/sprocketstask.rb b/debian/gems-compat/sprockets-2.12.4/lib/rake/sprocketstask.rb
new file mode 100644
index 0000000..7fb9c91
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/rake/sprocketstask.rb
@@ -0,0 +1,151 @@
+require 'rake'
+require 'rake/tasklib'
+
+require 'sprockets'
+require 'logger'
+
+module Rake
+ # Simple Sprockets compilation Rake task macro.
+ #
+ # Rake::SprocketsTask.new do |t|
+ # t.environment = Sprockets::Environment.new
+ # t.output = "./public/assets"
+ # t.assets = %w( application.js application.css )
+ # end
+ #
+ class SprocketsTask < Rake::TaskLib
+ # Name of the task. Defaults to "assets".
+ #
+ # The name will also be used to suffix the clean and clobber
+ # tasks, "clean_assets" and "clobber_assets".
+ attr_accessor :name
+
+ # `Environment` instance used for finding assets.
+ #
+ # You'll most likely want to reassign `environment` to your own.
+ #
+ # Rake::SprocketsTask.new do |t|
+ # t.environment = Foo::Assets
+ # end
+ #
+ def environment
+ if !@environment.is_a?(Sprockets::Base) && @environment.respond_to?(:call)
+ @environment = @environment.call
+ else
+ @environment
+ end
+ end
+ attr_writer :environment
+
+ # Returns cached indexed environment
+ def index
+ @index ||= environment.index if environment
+ end
+
+ # `Manifest` instance used for already compiled assets.
+ #
+ # Will be created by default if an environment and output
+ # directory are given
+ def manifest
+ if !@manifest.is_a?(Sprockets::Manifest) && @manifest.respond_to?(:call)
+ @manifest = @manifest.call
+ else
+ @manifest
+ end
+ end
+ attr_writer :manifest
+
+ # Directory to write compiled assets too. As well as the manifest file.
+ #
+ # t.output = "./public/assets"
+ #
+ attr_accessor :output
+
+ # Array of asset logical paths to compile.
+ #
+ # t.assets = %w( application.js jquery.js application.css )
+ #
+ attr_accessor :assets
+
+ # Number of old assets to keep.
+ attr_accessor :keep
+
+ # Logger to use during rake tasks. Defaults to using stderr.
+ #
+ # t.logger = Logger.new($stdout)
+ #
+ attr_accessor :logger
+
+ # Returns logger level Integer.
+ def log_level
+ @logger.level
+ end
+
+ # Set logger level with constant or symbol.
+ #
+ # t.log_level = Logger::INFO
+ # t.log_level = :debug
+ #
+ def log_level=(level)
+ if level.is_a?(Integer)
+ @logger.level = level
+ else
+ @logger.level = Logger.const_get(level.to_s.upcase)
+ end
+ end
+
+ def initialize(name = :assets)
+ @name = name
+ @environment = lambda { Sprockets::Environment.new(Dir.pwd) }
+ @manifest = lambda { Sprockets::Manifest.new(index, output) }
+ @logger = Logger.new($stderr)
+ @logger.level = Logger::INFO
+ @keep = 2
+
+ yield self if block_given?
+
+ define
+ end
+
+ # Define tasks
+ def define
+ desc name == :assets ? "Compile assets" : "Compile #{name} assets"
+ task name do
+ with_logger do
+ manifest.compile(assets)
+ end
+ end
+
+ desc name == :assets ? "Remove all assets" : "Remove all #{name} assets"
+ task "clobber_#{name}" do
+ with_logger do
+ manifest.clobber
+ end
+ end
+
+ task :clobber => ["clobber_#{name}"]
+
+ desc name == :assets ? "Clean old assets" : "Clean old #{name} assets"
+ task "clean_#{name}" do
+ with_logger do
+ manifest.clean(keep)
+ end
+ end
+
+ task :clean => ["clean_#{name}"]
+ end
+
+ private
+ # Sub out environment logger with our rake task logger that
+ # writes to stderr.
+ def with_logger
+ if env = manifest.environment
+ old_logger = env.logger
+ env.logger = @logger
+ end
+ yield
+ ensure
+ env.logger = old_logger if env
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets.rb
new file mode 100644
index 0000000..fa05242
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets.rb
@@ -0,0 +1,108 @@
+require 'sprockets/version'
+
+module Sprockets
+ # Environment
+ autoload :Base, "sprockets/base"
+ autoload :Environment, "sprockets/environment"
+ autoload :Index, "sprockets/index"
+ autoload :Manifest, "sprockets/manifest"
+
+ # Assets
+ autoload :Asset, "sprockets/asset"
+ autoload :BundledAsset, "sprockets/bundled_asset"
+ autoload :ProcessedAsset, "sprockets/processed_asset"
+ autoload :StaticAsset, "sprockets/static_asset"
+
+ # Processing
+ autoload :Context, "sprockets/context"
+ autoload :EcoTemplate, "sprockets/eco_template"
+ autoload :EjsTemplate, "sprockets/ejs_template"
+ autoload :JstProcessor, "sprockets/jst_processor"
+ autoload :Processor, "sprockets/processor"
+ autoload :SassCacheStore, "sprockets/sass_cache_store"
+ autoload :SassFunctions, "sprockets/sass_functions"
+ autoload :SassImporter, "sprockets/sass_importer"
+ autoload :SassTemplate, "sprockets/sass_template"
+ autoload :ScssTemplate, "sprockets/scss_template"
+
+ # Internal utilities
+ autoload :ArgumentError, "sprockets/errors"
+ autoload :AssetAttributes, "sprockets/asset_attributes"
+ autoload :CircularDependencyError, "sprockets/errors"
+ autoload :ContentTypeMismatch, "sprockets/errors"
+ autoload :EngineError, "sprockets/errors"
+ autoload :Error, "sprockets/errors"
+ autoload :FileNotFound, "sprockets/errors"
+ autoload :Utils, "sprockets/utils"
+
+ module Cache
+ autoload :FileStore, "sprockets/cache/file_store"
+ end
+
+ # Extend Sprockets module to provide global registry
+ require 'hike'
+ require 'sprockets/engines'
+ require 'sprockets/mime'
+ require 'sprockets/processing'
+ require 'sprockets/compressing'
+ require 'sprockets/paths'
+ extend Engines, Mime, Processing, Compressing, Paths
+
+ @trail = Hike::Trail.new(File.expand_path('..', __FILE__))
+ @mime_types = {}
+ @engines = {}
+ @preprocessors = Hash.new { |h, k| h[k] = [] }
+ @postprocessors = Hash.new { |h, k| h[k] = [] }
+ @bundle_processors = Hash.new { |h, k| h[k] = [] }
+ @compressors = Hash.new { |h, k| h[k] = {} }
+
+ register_mime_type 'text/css', '.css'
+ register_mime_type 'application/javascript', '.js'
+
+ require 'sprockets/directive_processor'
+ register_preprocessor 'text/css', DirectiveProcessor
+ register_preprocessor 'application/javascript', DirectiveProcessor
+
+ require 'sprockets/safety_colons'
+ register_postprocessor 'application/javascript', SafetyColons
+
+ require 'sprockets/charset_normalizer'
+ register_bundle_processor 'text/css', CharsetNormalizer
+
+ require 'sprockets/sass_compressor'
+ register_compressor 'text/css', :sass, SassCompressor
+ register_compressor 'text/css', :scss, SassCompressor
+
+ require 'sprockets/yui_compressor'
+ register_compressor 'text/css', :yui, YUICompressor
+
+ require 'sprockets/closure_compressor'
+ register_compressor 'application/javascript', :closure, ClosureCompressor
+
+ require 'sprockets/uglifier_compressor'
+ register_compressor 'application/javascript', :uglifier, UglifierCompressor
+ register_compressor 'application/javascript', :uglify, UglifierCompressor
+
+ require 'sprockets/yui_compressor'
+ register_compressor 'application/javascript', :yui, YUICompressor
+
+ # Cherry pick the default Tilt engines that make sense for
+ # Sprockets. We don't need ones that only generate html like HAML.
+
+ # Mmm, CoffeeScript
+ register_engine '.coffee', Tilt::CoffeeScriptTemplate
+
+ # JST engines
+ register_engine '.jst', JstProcessor
+ register_engine '.eco', EcoTemplate
+ register_engine '.ejs', EjsTemplate
+
+ # CSS engines
+ register_engine '.less', Tilt::LessTemplate
+ register_engine '.sass', SassTemplate
+ register_engine '.scss', ScssTemplate
+
+ # Other
+ register_engine '.erb', Tilt::ERBTemplate
+ register_engine '.str', Tilt::StringTemplate
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/asset.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/asset.rb
new file mode 100644
index 0000000..93163ca
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/asset.rb
@@ -0,0 +1,269 @@
+require 'time'
+require 'set'
+
+module Sprockets
+ # `Asset` is the base class for `BundledAsset` and `StaticAsset`.
+ class Asset
+ # Internal initializer to load `Asset` from serialized `Hash`.
+ def self.from_hash(environment, hash)
+ return unless hash.is_a?(Hash)
+
+ klass = case hash['class']
+ when 'BundledAsset'
+ BundledAsset
+ when 'ProcessedAsset'
+ ProcessedAsset
+ when 'StaticAsset'
+ StaticAsset
+ else
+ nil
+ end
+
+ if klass
+ asset = klass.allocate
+ asset.init_with(environment, hash)
+ asset
+ end
+ rescue UnserializeError
+ nil
+ end
+
+ attr_reader :logical_path, :pathname
+ attr_reader :content_type, :mtime, :length, :digest
+ alias_method :bytesize, :length
+
+ def initialize(environment, logical_path, pathname)
+ raise ArgumentError, "Asset logical path has no extension: #{logical_path}" if File.extname(logical_path) == ""
+
+ @root = environment.root
+ @logical_path = logical_path.to_s
+ @pathname = Pathname.new(pathname)
+ @content_type = environment.content_type_of(pathname)
+ # drop precision to 1 second, same pattern followed elsewhere
+ @mtime = Time.at(environment.stat(pathname).mtime.to_i)
+ @length = environment.stat(pathname).size
+ @digest = environment.file_digest(pathname).hexdigest
+ end
+
+ # Initialize `Asset` from serialized `Hash`.
+ def init_with(environment, coder)
+ @root = environment.root
+
+ @logical_path = coder['logical_path']
+ @content_type = coder['content_type']
+ @digest = coder['digest']
+
+ if pathname = coder['pathname']
+ # Expand `$root` placeholder and wrapper string in a `Pathname`
+ @pathname = Pathname.new(expand_root_path(pathname))
+ end
+
+ if mtime = coder['mtime']
+ @mtime = Time.at(mtime)
+ end
+
+ if length = coder['length']
+ # Convert length to an `Integer`
+ @length = Integer(length)
+ end
+ end
+
+ # Copy serialized attributes to the coder object
+ def encode_with(coder)
+ coder['class'] = self.class.name.sub(/Sprockets::/, '')
+ coder['logical_path'] = logical_path
+ coder['pathname'] = relativize_root_path(pathname).to_s
+ coder['content_type'] = content_type
+ coder['mtime'] = mtime.to_i
+ coder['length'] = length
+ coder['digest'] = digest
+ end
+
+ # Return logical path with digest spliced in.
+ #
+ # "foo/bar-37b51d194a7513e45b56f6524f2d51f2.js"
+ #
+ def digest_path
+ logical_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+ end
+
+ # Return an `Array` of `Asset` files that are declared dependencies.
+ def dependencies
+ []
+ end
+
+ # Expand asset into an `Array` of parts.
+ #
+ # Appending all of an assets body parts together should give you
+ # the asset's contents as a whole.
+ #
+ # This allows you to link to individual files for debugging
+ # purposes.
+ def to_a
+ [self]
+ end
+
+ # `body` is aliased to source by default if it can't have any dependencies.
+ def body
+ source
+ end
+
+ # Return `String` of concatenated source.
+ def to_s
+ source
+ end
+
+ # Add enumerator to allow `Asset` instances to be used as Rack
+ # compatible body objects.
+ def each
+ yield to_s
+ end
+
+ # Checks if Asset is fresh by comparing the actual mtime and
+ # digest to the inmemory model.
+ #
+ # Used to test if cached models need to be rebuilt.
+ def fresh?(environment)
+ # Check current mtime and digest
+ dependency_fresh?(environment, self)
+ end
+
+ # Checks if Asset is stale by comparing the actual mtime and
+ # digest to the inmemory model.
+ #
+ # Subclass must override `fresh?` or `stale?`.
+ def stale?(environment)
+ !fresh?(environment)
+ end
+
+ # Save asset to disk.
+ def write_to(filename, options = {})
+ # Gzip contents if filename has '.gz'
+ unless options.key?(:compress)
+ options[:compress] = File.extname(filename) == '.gz' && File.extname(logical_path) != '.gz'
+ end
+
+ FileUtils.mkdir_p File.dirname(filename)
+
+ File.open("#{filename}+", 'wb') do |f|
+ if options[:compress]
+ # Run contents through `Zlib`
+ gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+ gz.mtime = mtime.to_i
+ gz.write to_s
+ gz.close
+ else
+ # Write out as is
+ f.write to_s
+ end
+ end
+
+ # Atomic write
+ FileUtils.mv("#{filename}+", filename)
+
+ # Set mtime correctly
+ File.utime(mtime, mtime, filename)
+
+ nil
+ ensure
+ # Ensure tmp file gets cleaned up
+ FileUtils.rm("#{filename}+") if File.exist?("#{filename}+")
+ end
+
+ # Pretty inspect
+ def inspect
+ "#<#{self.class}:0x#{object_id.to_s(16)} " +
+ "pathname=#{pathname.to_s.inspect}, " +
+ "mtime=#{mtime.inspect}, " +
+ "digest=#{digest.inspect}" +
+ ">"
+ end
+
+ def hash
+ digest.hash
+ end
+
+ # Assets are equal if they share the same path, mtime and digest.
+ def eql?(other)
+ other.class == self.class &&
+ other.logical_path == self.logical_path &&
+ other.mtime.to_i == self.mtime.to_i &&
+ other.digest == self.digest
+ end
+ alias_method :==, :eql?
+
+ protected
+ # Internal: String paths that are marked as dependencies after processing.
+ #
+ # Default to an empty `Array`.
+ def dependency_paths
+ @dependency_paths ||= []
+ end
+
+ # Internal: `ProccessedAsset`s that are required after processing.
+ #
+ # Default to an empty `Array`.
+ def required_assets
+ @required_assets ||= []
+ end
+
+ # Get pathname with its root stripped.
+ def relative_pathname
+ @relative_pathname ||= Pathname.new(relativize_root_path(pathname))
+ end
+
+ # Replace `$root` placeholder with actual environment root.
+ def expand_root_path(path)
+ path.to_s.sub(/^\$root/, @root)
+ end
+
+ # Replace actual environment root with `$root` placeholder.
+ def relativize_root_path(path)
+ path.to_s.sub(/^#{Regexp.escape(@root)}/, '$root')
+ end
+
+ # Check if dependency is fresh.
+ #
+ # `dep` is a `Hash` with `path`, `mtime` and `hexdigest` keys.
+ #
+ # A `Hash` is used rather than other `Asset` object because we
+ # want to test non-asset files and directories.
+ def dependency_fresh?(environment, dep)
+ path, mtime, hexdigest = dep.pathname.to_s, dep.mtime, dep.digest
+
+ stat = environment.stat(path)
+
+ # If path no longer exists, its definitely stale.
+ if stat.nil?
+ return false
+ end
+
+ # Compare dependency mtime to the actual mtime. If the
+ # dependency mtime is newer than the actual mtime, the file
+ # hasn't changed since we created this `Asset` instance.
+ #
+ # However, if the mtime is newer it doesn't mean the asset is
+ # stale. Many deployment environments may recopy or recheckout
+ # assets on each deploy. In this case the mtime would be the
+ # time of deploy rather than modified time.
+ #
+ # Note: to_i is used in eql? and write_to we assume fidelity of 1 second
+ # if people save files more frequently than 1 second sprockets may
+ # not pick it up, by design
+ if mtime.to_i >= stat.mtime.to_i
+ return true
+ end
+
+ digest = environment.file_digest(path)
+
+ # If the mtime is newer, do a full digest comparsion. Return
+ # fresh if the digests match.
+ if hexdigest == digest.hexdigest
+ return true
+ end
+
+ # Otherwise, its stale.
+ false
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/asset_attributes.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/asset_attributes.rb
new file mode 100644
index 0000000..807d660
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/asset_attributes.rb
@@ -0,0 +1,137 @@
+require 'pathname'
+
+module Sprockets
+ # `AssetAttributes` is a wrapper similar to `Pathname` that provides
+ # some helper accessors.
+ #
+ # These methods should be considered internalish.
+ class AssetAttributes
+ attr_reader :environment, :pathname
+
+ def initialize(environment, path)
+ @environment = environment
+ @pathname = path.is_a?(Pathname) ? path : Pathname.new(path.to_s)
+ end
+
+ # Returns paths search the load path for.
+ def search_paths
+ paths = [pathname.to_s]
+
+ extension = format_extension
+ path_without_extension = extension ?
+ pathname.sub(extension, '') :
+ pathname
+
+ # optimization: bower.json can only be nested one level deep
+ if !path_without_extension.to_s.index('/')
+ paths << path_without_extension.join(".bower.json").to_s
+ paths << path_without_extension.join("bower.json").to_s
+ # DEPRECATED bower configuration file
+ paths << path_without_extension.join("component.json").to_s
+ end
+
+ if pathname.basename(extension.to_s).to_s != 'index'
+ paths << path_without_extension.join("index#{extension}").to_s
+ end
+
+ paths
+ end
+
+ # Reverse guess logical path for fully expanded path.
+ #
+ # This has some known issues. For an example if a file is
+ # shaddowed in the path, but is required relatively, its logical
+ # path will be incorrect.
+ def logical_path
+ if root_path = environment.paths.detect { |path| pathname.to_s[path] }
+ path = pathname.to_s.sub("#{root_path}/", '')
+ path = pathname.relative_path_from(Pathname.new(root_path)).to_s
+ path = engine_extensions.inject(path) { |p, ext| p.sub(ext, '') }
+ path = "#{path}#{engine_format_extension}" unless format_extension
+ path
+ else
+ raise FileOutsidePaths, "#{pathname} isn't in paths: #{environment.paths.join(', ')}"
+ end
+ end
+
+ # Returns `Array` of extension `String`s.
+ #
+ # "foo.js.coffee"
+ # # => [".js", ".coffee"]
+ #
+ def extensions
+ @extensions ||= @pathname.basename.to_s.scan(/\.[^.]+/)
+ end
+
+ # Returns the format extension.
+ #
+ # "foo.js.coffee"
+ # # => ".js"
+ #
+ def format_extension
+ extensions.reverse.detect { |ext|
+ @environment.mime_types(ext) && !@environment.engines(ext)
+ }
+ end
+
+ # Returns an `Array` of engine extensions.
+ #
+ # "foo.js.coffee.erb"
+ # # => [".coffee", ".erb"]
+ #
+ def engine_extensions
+ exts = extensions
+
+ if offset = extensions.index(format_extension)
+ exts = extensions[offset+1..-1]
+ end
+
+ exts.select { |ext| @environment.engines(ext) }
+ end
+
+ # Returns engine classes.
+ def engines
+ engine_extensions.map { |ext| @environment.engines(ext) }
+ end
+
+ # Returns all processors to run on the path.
+ def processors
+ environment.preprocessors(content_type) +
+ engines.reverse +
+ environment.postprocessors(content_type)
+ end
+
+ # Returns the content type for the pathname. Falls back to `application/octet-stream`.
+ def content_type
+ @content_type ||= begin
+ if format_extension.nil?
+ engine_content_type || 'application/octet-stream'
+ else
+ @environment.mime_types(format_extension) ||
+ engine_content_type ||
+ 'application/octet-stream'
+ end
+ end
+ end
+
+ private
+ # Returns implicit engine content type.
+ #
+ # `.coffee` files carry an implicit `application/javascript`
+ # content type.
+ def engine_content_type
+ engines.reverse.each do |engine|
+ if engine.respond_to?(:default_mime_type) && engine.default_mime_type
+ return engine.default_mime_type
+ end
+ end
+ nil
+ end
+
+ def engine_format_extension
+ if content_type = engine_content_type
+ environment.extension_for_mime_type(content_type)
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/base.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/base.rb
new file mode 100644
index 0000000..27ee705
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/base.rb
@@ -0,0 +1,447 @@
+require 'sprockets/asset_attributes'
+require 'sprockets/bundled_asset'
+require 'sprockets/caching'
+require 'sprockets/errors'
+require 'sprockets/processed_asset'
+require 'sprockets/server'
+require 'sprockets/static_asset'
+require 'multi_json'
+require 'pathname'
+
+module Sprockets
+ # `Base` class for `Environment` and `Index`.
+ class Base
+ include Caching, Paths, Mime, Processing, Compressing, Engines, Server
+
+ # Returns a `Digest` implementation class.
+ #
+ # Defaults to `Digest::MD5`.
+ attr_reader :digest_class
+
+ # Assign a `Digest` implementation class. This may be any Ruby
+ # `Digest::` implementation such as `Digest::MD5` or
+ # `Digest::SHA1`.
+ #
+ # environment.digest_class = Digest::SHA1
+ #
+ def digest_class=(klass)
+ expire_index!
+ @digest_class = klass
+ end
+
+ # The `Environment#version` is a custom value used for manually
+ # expiring all asset caches.
+ #
+ # Sprockets is able to track most file and directory changes and
+ # will take care of expiring the cache for you. However, its
+ # impossible to know when any custom helpers change that you mix
+ # into the `Context`.
+ #
+ # It would be wise to increment this value anytime you make a
+ # configuration change to the `Environment` object.
+ attr_reader :version
+
+ # Assign an environment version.
+ #
+ # environment.version = '2.0'
+ #
+ def version=(version)
+ expire_index!
+ @version = version
+ end
+
+ # Returns a `Digest` instance for the `Environment`.
+ #
+ # This value serves two purposes. If two `Environment`s have the
+ # same digest value they can be treated as equal. This is more
+ # useful for comparing environment states between processes rather
+ # than in the same. Two equal `Environment`s can share the same
+ # cached assets.
+ #
+ # The value also provides a seed digest for all `Asset`
+ # digests. Any change in the environment digest will affect all of
+ # its assets.
+ def digest
+ # Compute the initial digest using the implementation class. The
+ # Sprockets release version and custom environment version are
+ # mixed in. So any new releases will affect all your assets.
+ @digest ||= digest_class.new.update(VERSION).update(version.to_s)
+
+ # Returned a dupped copy so the caller can safely mutate it with `.update`
+ @digest.dup
+ end
+
+ # Get and set `Logger` instance.
+ attr_accessor :logger
+
+ # Get `Context` class.
+ #
+ # This class maybe mutated and mixed in with custom helpers.
+ #
+ # environment.context_class.instance_eval do
+ # include MyHelpers
+ # def asset_url; end
+ # end
+ #
+ attr_reader :context_class
+
+ # Get persistent cache store
+ attr_reader :cache
+
+ # Set persistent cache store
+ #
+ # The cache store must implement a pair of getters and
+ # setters. Either `get(key)`/`set(key, value)`,
+ # `[key]`/`[key]=value`, `read(key)`/`write(key, value)`.
+ def cache=(cache)
+ expire_index!
+ @cache = cache
+ end
+
+ def prepend_path(path)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def append_path(path)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def clear_paths
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ # Finds the expanded real path for a given logical path by
+ # searching the environment's paths.
+ #
+ # resolve("application.js")
+ # # => "/path/to/app/javascripts/application.js.coffee"
+ #
+ # A `FileNotFound` exception is raised if the file does not exist.
+ def resolve(logical_path, options = {})
+ # If a block is given, preform an iterable search
+ if block_given?
+ args = attributes_for(logical_path).search_paths + [options]
+ @trail.find(*args) do |path|
+ pathname = Pathname.new(path)
+ if %w( .bower.json bower.json component.json ).include?(pathname.basename.to_s)
+ bower = json_decode(pathname.read)
+ case bower['main']
+ when String
+ yield pathname.dirname.join(bower['main'])
+ when Array
+ extname = File.extname(logical_path)
+ bower['main'].each do |fn|
+ if extname == "" || extname == File.extname(fn)
+ yield pathname.dirname.join(fn)
+ end
+ end
+ end
+ else
+ yield pathname
+ end
+ end
+ else
+ resolve(logical_path, options) do |pathname|
+ return pathname
+ end
+ raise FileNotFound, "couldn't find file '#{logical_path}'"
+ end
+ end
+
+ # Register a new mime type.
+ def register_mime_type(mime_type, ext)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ @trail.append_extension(ext)
+ super
+ end
+
+ # Registers a new Engine `klass` for `ext`.
+ def register_engine(ext, klass)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ add_engine_to_trail(ext, klass)
+ super
+ end
+
+ def register_preprocessor(mime_type, klass, &block)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def unregister_preprocessor(mime_type, klass)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def register_postprocessor(mime_type, klass, &block)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def unregister_postprocessor(mime_type, klass)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def register_bundle_processor(mime_type, klass, &block)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ def unregister_bundle_processor(mime_type, klass)
+ # Overrides the global behavior to expire the index
+ expire_index!
+ super
+ end
+
+ # Return an `Index`. Must be implemented by the subclass.
+ def index
+ raise NotImplementedError
+ end
+
+ if defined? Encoding.default_external
+ # Define `default_external_encoding` accessor on 1.9.
+ # Defaults to UTF-8.
+ attr_accessor :default_external_encoding
+ end
+
+ # Works like `Dir.entries`.
+ #
+ # Subclasses may cache this method.
+ def entries(pathname)
+ @trail.entries(pathname)
+ end
+
+ # Works like `File.stat`.
+ #
+ # Subclasses may cache this method.
+ def stat(path)
+ @trail.stat(path)
+ end
+
+ # Read and compute digest of filename.
+ #
+ # Subclasses may cache this method.
+ def file_digest(path)
+ if stat = self.stat(path)
+ # If its a file, digest the contents
+ if stat.file?
+ digest.file(path.to_s)
+
+ # If its a directive, digest the list of filenames
+ elsif stat.directory?
+ contents = self.entries(path).join(',')
+ digest.update(contents)
+ end
+ end
+ end
+
+ # Internal. Return a `AssetAttributes` for `path`.
+ def attributes_for(path)
+ AssetAttributes.new(self, path)
+ end
+
+ # Internal. Return content type of `path`.
+ def content_type_of(path)
+ attributes_for(path).content_type
+ end
+
+ # Find asset by logical path or expanded path.
+ def find_asset(path, options = {})
+ logical_path = path
+ pathname = Pathname.new(path).cleanpath
+
+ if pathname.absolute?
+ return unless stat(pathname)
+ logical_path = attributes_for(pathname).logical_path
+ else
+ begin
+ pathname = resolve(logical_path)
+
+ # If logical path is missing a mime type extension, append
+ # the absolute path extname so it has one.
+ #
+ # Ensures some consistency between finding "foo/bar" vs
+ # "foo/bar.js".
+ if File.extname(logical_path) == ""
+ expanded_logical_path = attributes_for(pathname).logical_path
+ logical_path += File.extname(expanded_logical_path)
+ end
+ rescue FileNotFound
+ return nil
+ end
+ end
+
+ build_asset(logical_path, pathname, options)
+ end
+
+ # Preferred `find_asset` shorthand.
+ #
+ # environment['application.js']
+ #
+ def [](*args)
+ find_asset(*args)
+ end
+
+ def each_entry(root, &block)
+ return to_enum(__method__, root) unless block_given?
+ root = Pathname.new(root) unless root.is_a?(Pathname)
+
+ paths = []
+ entries(root).sort.each do |filename|
+ path = root.join(filename)
+ paths << path
+
+ if stat(path).directory?
+ each_entry(path) do |subpath|
+ paths << subpath
+ end
+ end
+ end
+
+ paths.sort_by(&:to_s).each(&block)
+
+ nil
+ end
+
+ def each_file
+ return to_enum(__method__) unless block_given?
+ paths.each do |root|
+ each_entry(root) do |path|
+ if !stat(path).directory?
+ yield path
+ end
+ end
+ end
+ nil
+ end
+
+ def each_logical_path(*args, &block)
+ return to_enum(__method__, *args) unless block_given?
+ filters = args.flatten
+ files = {}
+ each_file do |filename|
+ if logical_path = logical_path_for_filename(filename, filters)
+ unless files[logical_path]
+ if block.arity == 2
+ yield logical_path, filename.to_s
+ else
+ yield logical_path
+ end
+ end
+
+ files[logical_path] = true
+ end
+ end
+ nil
+ end
+
+ # Pretty inspect
+ def inspect
+ "#<#{self.class}:0x#{object_id.to_s(16)} " +
+ "root=#{root.to_s.inspect}, " +
+ "paths=#{paths.inspect}, " +
+ "digest=#{digest.to_s.inspect}" +
+ ">"
+ end
+
+ protected
+ # Clear index after mutating state. Must be implemented by the subclass.
+ def expire_index!
+ raise NotImplementedError
+ end
+
+ def build_asset(logical_path, pathname, options)
+ pathname = Pathname.new(pathname)
+
+ # If there are any processors to run on the pathname, use
+ # `BundledAsset`. Otherwise use `StaticAsset` and treat is as binary.
+ if attributes_for(pathname).processors.any?
+ if options[:bundle] == false
+ circular_call_protection(pathname.to_s) do
+ ProcessedAsset.new(index, logical_path, pathname)
+ end
+ else
+ BundledAsset.new(index, logical_path, pathname)
+ end
+ else
+ StaticAsset.new(index, logical_path, pathname)
+ end
+ end
+
+ def cache_key_for(path, options)
+ "#{path}:#{options[:bundle] ? '1' : '0'}"
+ end
+
+ def circular_call_protection(path)
+ reset = Thread.current[:sprockets_circular_calls].nil?
+ calls = Thread.current[:sprockets_circular_calls] ||= Set.new
+ if calls.include?(path)
+ raise CircularDependencyError, "#{path} has already been required"
+ end
+ calls << path
+ yield
+ ensure
+ Thread.current[:sprockets_circular_calls] = nil if reset
+ end
+
+ def logical_path_for_filename(filename, filters)
+ logical_path = attributes_for(filename).logical_path.to_s
+
+ if matches_filter(filters, logical_path, filename)
+ return logical_path
+ end
+
+ # If filename is an index file, retest with alias
+ if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
+ path = logical_path.sub(/\/index\./, '.')
+ if matches_filter(filters, path, filename)
+ return path
+ end
+ end
+
+ nil
+ end
+
+ def matches_filter(filters, logical_path, filename)
+ return true if filters.empty?
+
+ filters.any? do |filter|
+ if filter.is_a?(Regexp)
+ filter.match(logical_path)
+ elsif filter.respond_to?(:call)
+ if filter.arity == 1
+ filter.call(logical_path)
+ else
+ filter.call(logical_path, filename.to_s)
+ end
+ else
+ File.fnmatch(filter.to_s, logical_path)
+ end
+ end
+ end
+
+ # Feature detect newer MultiJson API
+ if MultiJson.respond_to?(:dump)
+ def json_decode(obj)
+ MultiJson.load(obj)
+ end
+ else
+ def json_decode(obj)
+ MultiJson.decode(obj)
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/bundled_asset.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/bundled_asset.rb
new file mode 100644
index 0000000..1b2e810
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/bundled_asset.rb
@@ -0,0 +1,78 @@
+require 'sprockets/asset'
+require 'sprockets/errors'
+require 'fileutils'
+require 'set'
+require 'zlib'
+
+module Sprockets
+ # `BundledAsset`s are used for files that need to be processed and
+ # concatenated with other assets. Use for `.js` and `.css` files.
+ class BundledAsset < Asset
+ attr_reader :source
+
+ def initialize(environment, logical_path, pathname)
+ super(environment, logical_path, pathname)
+
+ @processed_asset = environment.find_asset(pathname, :bundle => false)
+ @required_assets = @processed_asset.required_assets
+ @dependency_paths = @processed_asset.dependency_paths
+
+ # Explode Asset into parts and gather the dependency bodies
+ @source = to_a.map { |dependency| dependency.to_s }.join
+
+ # Run bundle processors on concatenated source
+ context = environment.context_class.new(environment, logical_path, pathname)
+ @source = context.evaluate(pathname, :data => @source,
+ :processors => environment.bundle_processors(content_type))
+
+ @mtime = (to_a + @dependency_paths).map(&:mtime).max
+ @length = Rack::Utils.bytesize(source)
+ @digest = environment.digest.update(source).hexdigest
+ end
+
+ # Initialize `BundledAsset` from serialized `Hash`.
+ def init_with(environment, coder)
+ super
+
+ @processed_asset = environment.find_asset(pathname, :bundle => false)
+ @required_assets = @processed_asset.required_assets
+
+ if @processed_asset.dependency_digest != coder['required_assets_digest']
+ raise UnserializeError, "processed asset belongs to a stale environment"
+ end
+
+ @source = coder['source']
+ end
+
+ # Serialize custom attributes in `BundledAsset`.
+ def encode_with(coder)
+ super
+
+ coder['source'] = source
+ coder['required_assets_digest'] = @processed_asset.dependency_digest
+ end
+
+ # Get asset's own processed contents. Excludes any of its required
+ # dependencies but does run any processors or engines on the
+ # original file.
+ def body
+ @processed_asset.source
+ end
+
+ # Return an `Array` of `Asset` files that are declared dependencies.
+ def dependencies
+ to_a.reject { |a| a.eql?(@processed_asset) }
+ end
+
+ # Expand asset into an `Array` of parts.
+ def to_a
+ required_assets
+ end
+
+ # Checks if Asset is stale by comparing the actual mtime and
+ # digest to the inmemory model.
+ def fresh?(environment)
+ @processed_asset.fresh?(environment)
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/cache/file_store.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/cache/file_store.rb
new file mode 100644
index 0000000..bcb4694
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/cache/file_store.rb
@@ -0,0 +1,32 @@
+require 'digest/md5'
+require 'fileutils'
+require 'pathname'
+
+module Sprockets
+ module Cache
+ # A simple file system cache store.
+ #
+ # environment.cache = Sprockets::Cache::FileStore.new("/tmp")
+ #
+ class FileStore
+ def initialize(root)
+ @root = Pathname.new(root)
+ end
+
+ # Lookup value in cache
+ def [](key)
+ pathname = @root.join(key)
+ pathname.exist? ? pathname.open('rb') { |f| Marshal.load(f) } : nil
+ end
+
+ # Save value to cache
+ def []=(key, value)
+ # Ensure directory exists
+ FileUtils.mkdir_p @root.join(key).dirname
+
+ @root.join(key).open('w') { |f| Marshal.dump(value, f)}
+ value
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/caching.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/caching.rb
new file mode 100644
index 0000000..7ca020d
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/caching.rb
@@ -0,0 +1,96 @@
+module Sprockets
+ # `Caching` is an internal mixin whose public methods are exposed on
+ # the `Environment` and `Index` classes.
+ module Caching
+ # Low level cache getter for `key`. Checks a number of supported
+ # cache interfaces.
+ def cache_get(key)
+ # `Cache#get(key)` for Memcache
+ if cache.respond_to?(:get)
+ cache.get(key)
+
+ # `Cache#[key]` so `Hash` can be used
+ elsif cache.respond_to?(:[])
+ cache[key]
+
+ # `Cache#read(key)` for `ActiveSupport::Cache` support
+ elsif cache.respond_to?(:read)
+ cache.read(key)
+
+ else
+ nil
+ end
+ end
+
+ # Low level cache setter for `key`. Checks a number of supported
+ # cache interfaces.
+ def cache_set(key, value)
+ # `Cache#set(key, value)` for Memcache
+ if cache.respond_to?(:set)
+ cache.set(key, value)
+
+ # `Cache#[key]=value` so `Hash` can be used
+ elsif cache.respond_to?(:[]=)
+ cache[key] = value
+
+ # `Cache#write(key, value)` for `ActiveSupport::Cache` support
+ elsif cache.respond_to?(:write)
+ cache.write(key, value)
+ end
+
+ value
+ end
+
+ protected
+ # Cache helper method. Takes a `path` argument which maybe a
+ # logical path or fully expanded path. The `&block` is passed
+ # for finding and building the asset if its not in cache.
+ def cache_asset(path)
+ # If `cache` is not set, return fast
+ if cache.nil?
+ yield
+
+ # Check cache for `path`
+ elsif (asset = Asset.from_hash(self, cache_get_hash(path.to_s))) && asset.fresh?(self)
+ asset
+
+ # Otherwise yield block that slowly finds and builds the asset
+ elsif asset = yield
+ hash = {}
+ asset.encode_with(hash)
+
+ # Save the asset to its path
+ cache_set_hash(path.to_s, hash)
+
+ # Since path maybe a logical or full pathname, save the
+ # asset its its full path too
+ if path.to_s != asset.pathname.to_s
+ cache_set_hash(asset.pathname.to_s, hash)
+ end
+
+ asset
+ end
+ end
+
+ private
+ # Strips `Environment#root` from key to make the key work
+ # consisently across different servers. The key is also hashed
+ # so it does not exceed 250 characters.
+ def expand_cache_key(key)
+ File.join('sprockets', digest_class.hexdigest(key.sub(root, '')))
+ end
+
+ def cache_get_hash(key)
+ hash = cache_get(expand_cache_key(key))
+ if hash.is_a?(Hash) && digest.hexdigest == hash['_version']
+ hash
+ end
+ end
+
+ def cache_set_hash(key, hash)
+ hash['_version'] = digest.hexdigest
+ cache_set(expand_cache_key(key), hash)
+ hash
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/charset_normalizer.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/charset_normalizer.rb
new file mode 100644
index 0000000..daa4e38
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/charset_normalizer.rb
@@ -0,0 +1,41 @@
+require 'tilt'
+
+module Sprockets
+ # Some browsers have issues with stylesheets that contain multiple
+ # `@charset` definitions. The issue surfaces while using Sass since
+ # it inserts a `@charset` at the top of each file. Then Sprockets
+ # concatenates them together.
+ #
+ # The `CharsetNormalizer` processor strips out multiple `@charset`
+ # definitions.
+ #
+ # The current implementation is naive. It picks the first `@charset`
+ # it sees and strips the others. This works for most people because
+ # the other definitions are usually `UTF-8`. A more sophisticated
+ # approach would be to re-encode stylesheets with mixed encodings.
+ #
+ # This behavior can be disabled with:
+ #
+ # environment.unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
+ #
+ class CharsetNormalizer < Tilt::Template
+ def prepare
+ end
+
+ def evaluate(context, locals, &block)
+ charset = nil
+
+ # Find and strip out any `@charset` definitions
+ filtered_data = data.gsub(/^@charset "([^"]+)";$/) {
+ charset ||= $1; ""
+ }
+
+ if charset
+ # If there was a charset, move it to the top
+ "@charset \"#{charset}\";#{filtered_data}"
+ else
+ data
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/closure_compressor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/closure_compressor.rb
new file mode 100644
index 0000000..567ca16
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/closure_compressor.rb
@@ -0,0 +1,22 @@
+require 'tilt'
+
+module Sprockets
+ class ClosureCompressor < Tilt::Template
+ self.default_mime_type = 'application/javascript'
+
+ def self.engine_initialized?
+ defined?(::Closure::Compiler)
+ end
+
+ def initialize_engine
+ require_template_library 'closure-compiler'
+ end
+
+ def prepare
+ end
+
+ def evaluate(context, locals, &block)
+ Closure::Compiler.new.compile(data)
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/compressing.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/compressing.rb
new file mode 100644
index 0000000..6634125
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/compressing.rb
@@ -0,0 +1,73 @@
+module Sprockets
+ # `Compressing` is an internal mixin whose public methods are exposed on
+ # the `Environment` and `Index` classes.
+ module Compressing
+ def compressors
+ deep_copy_hash(@compressors)
+ end
+
+ def register_compressor(mime_type, sym, klass)
+ @compressors[mime_type][sym] = klass
+ end
+
+ # Return CSS compressor or nil if none is set
+ def css_compressor
+ @css_compressor if defined? @css_compressor
+ end
+
+ # Assign a compressor to run on `text/css` assets.
+ #
+ # The compressor object must respond to `compress`.
+ def css_compressor=(compressor)
+ unregister_bundle_processor 'text/css', css_compressor if css_compressor
+ @css_compressor = nil
+ return unless compressor
+
+ if compressor.is_a?(Symbol)
+ compressor = compressors['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+ end
+
+ if compressor.respond_to?(:compress)
+ klass = Class.new(Processor) do
+ @name = "css_compressor"
+ @processor = proc { |context, data| compressor.compress(data) }
+ end
+ @css_compressor = :css_compressor
+ else
+ @css_compressor = klass = compressor
+ end
+
+ register_bundle_processor 'text/css', klass
+ end
+
+ # Return JS compressor or nil if none is set
+ def js_compressor
+ @js_compressor if defined? @js_compressor
+ end
+
+ # Assign a compressor to run on `application/javascript` assets.
+ #
+ # The compressor object must respond to `compress`.
+ def js_compressor=(compressor)
+ unregister_bundle_processor 'application/javascript', js_compressor if js_compressor
+ @js_compressor = nil
+ return unless compressor
+
+ if compressor.is_a?(Symbol)
+ compressor = compressors['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+ end
+
+ if compressor.respond_to?(:compress)
+ klass = Class.new(Processor) do
+ @name = "js_compressor"
+ @processor = proc { |context, data| compressor.compress(data) }
+ end
+ @js_compressor = :js_compressor
+ else
+ @js_compressor = klass = compressor
+ end
+
+ register_bundle_processor 'application/javascript', klass
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/context.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/context.rb
new file mode 100644
index 0000000..9b13406
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/context.rb
@@ -0,0 +1,289 @@
+require 'base64'
+require 'rack/utils'
+require 'sprockets/errors'
+require 'sprockets/utils'
+require 'pathname'
+require 'set'
+
+module Sprockets
+ # `Context` provides helper methods to all `Tilt` processors. They
+ # are typically accessed by ERB templates. You can mix in custom
+ # helpers by injecting them into `Environment#context_class`. Do not
+ # mix them into `Context` directly.
+ #
+ # environment.context_class.class_eval do
+ # include MyHelper
+ # def asset_url; end
+ # end
+ #
+ # <%= asset_url "foo.png" %>
+ #
+ # The `Context` also collects dependencies declared by
+ # assets. See `DirectiveProcessor` for an example of this.
+ class Context
+ attr_reader :environment, :pathname
+ attr_reader :_required_paths, :_stubbed_assets
+ attr_reader :_dependency_paths, :_dependency_assets
+ attr_writer :__LINE__
+
+ def initialize(environment, logical_path, pathname)
+ @environment = environment
+ @logical_path = logical_path
+ @pathname = pathname
+ @__LINE__ = nil
+
+ @_required_paths = []
+ @_stubbed_assets = Set.new
+ @_dependency_paths = Set.new
+ @_dependency_assets = Set.new([pathname.to_s])
+ end
+
+ # Returns the environment path that contains the file.
+ #
+ # If `app/javascripts` and `app/stylesheets` are in your path, and
+ # current file is `app/javascripts/foo/bar.js`, `root_path` would
+ # return `app/javascripts`.
+ def root_path
+ environment.paths.detect { |path| pathname.to_s[path] }
+ end
+
+ # Returns logical path without any file extensions.
+ #
+ # 'app/javascripts/application.js'
+ # # => 'application'
+ #
+ def logical_path
+ @logical_path.chomp(File.extname(@logical_path))
+ end
+
+ # Returns content type of file
+ #
+ # 'application/javascript'
+ # 'text/css'
+ #
+ def content_type
+ environment.content_type_of(pathname)
+ end
+
+ # Given a logical path, `resolve` will find and return the fully
+ # expanded path. Relative paths will also be resolved. An optional
+ # `:content_type` restriction can be supplied to restrict the
+ # search.
+ #
+ # resolve("foo.js")
+ # # => "/path/to/app/javascripts/foo.js"
+ #
+ # resolve("./bar.js")
+ # # => "/path/to/app/javascripts/bar.js"
+ #
+ def resolve(path, options = {}, &block)
+ pathname = Pathname.new(path)
+ attributes = environment.attributes_for(pathname)
+
+ if pathname.absolute?
+ if environment.stat(pathname)
+ pathname
+ else
+ raise FileNotFound, "couldn't find file '#{pathname}'"
+ end
+
+ elsif content_type = options[:content_type]
+ content_type = self.content_type if content_type == :self
+
+ if attributes.format_extension
+ if content_type != attributes.content_type
+ raise ContentTypeMismatch, "#{path} is " +
+ "'#{attributes.content_type}', not '#{content_type}'"
+ end
+ end
+
+ resolve(path) do |candidate|
+ if self.content_type == environment.content_type_of(candidate)
+ return candidate
+ end
+ end
+
+ raise FileNotFound, "couldn't find file '#{path}'"
+ else
+ environment.resolve(path, {:base_path => self.pathname.dirname}.merge(options), &block)
+ end
+ end
+
+ # `depend_on` allows you to state a dependency on a file without
+ # including it.
+ #
+ # This is used for caching purposes. Any changes made to
+ # the dependency file with invalidate the cache of the
+ # source file.
+ def depend_on(path)
+ @_dependency_paths << resolve(path).to_s
+ nil
+ end
+
+ # `depend_on_asset` allows you to state an asset dependency
+ # without including it.
+ #
+ # This is used for caching purposes. Any changes that would
+ # invalidate the dependency asset will invalidate the source
+ # file. Unlike `depend_on`, this will include recursively include
+ # the target asset's dependencies.
+ def depend_on_asset(path)
+ filename = resolve(path).to_s
+ @_dependency_assets << filename
+ nil
+ end
+
+ # `require_asset` declares `path` as a dependency of the file. The
+ # dependency will be inserted before the file and will only be
+ # included once.
+ #
+ # If ERB processing is enabled, you can use it to dynamically
+ # require assets.
+ #
+ # <%= require_asset "#{framework}.js" %>
+ #
+ def require_asset(path)
+ pathname = resolve(path, :content_type => :self)
+ depend_on_asset(pathname)
+ @_required_paths << pathname.to_s
+ nil
+ end
+
+ # `stub_asset` blacklists `path` from being included in the bundle.
+ # `path` must be an asset which may or may not already be included
+ # in the bundle.
+ def stub_asset(path)
+ @_stubbed_assets << resolve(path, :content_type => :self).to_s
+ nil
+ end
+
+ # Tests if target path is able to be safely required into the
+ # current concatenation.
+ def asset_requirable?(path)
+ pathname = resolve(path)
+ content_type = environment.content_type_of(pathname)
+ stat = environment.stat(path)
+ return false unless stat && stat.file?
+ self.content_type.nil? || self.content_type == content_type
+ end
+
+ # Reads `path` and runs processors on the file.
+ #
+ # This allows you to capture the result of an asset and include it
+ # directly in another.
+ #
+ # <%= evaluate "bar.js" %>
+ #
+ def evaluate(path, options = {})
+ pathname = resolve(path)
+ attributes = environment.attributes_for(pathname)
+ processors = options[:processors] || attributes.processors
+
+ if options[:data]
+ result = options[:data]
+ else
+ if environment.respond_to?(:default_external_encoding)
+ mime_type = environment.mime_types(pathname.extname)
+ encoding = environment.encoding_for_mime_type(mime_type)
+ result = Sprockets::Utils.read_unicode(pathname, encoding)
+ else
+ result = Sprockets::Utils.read_unicode(pathname)
+ end
+ end
+
+ processors.each do |processor|
+ begin
+ template = processor.new(pathname.to_s) { result }
+ result = template.render(self, {})
+ rescue Exception => e
+ annotate_exception! e
+ raise
+ end
+ end
+
+ result
+ end
+
+ # Returns a Base64-encoded `data:` URI with the contents of the
+ # asset at the specified path, and marks that path as a dependency
+ # of the current file.
+ #
+ # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
+ #
+ # #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
+ #
+ # $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
+ #
+ def asset_data_uri(path)
+ depend_on_asset(path)
+ asset = environment.find_asset(path)
+ base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
+ "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
+ end
+
+ # Expands logical path to full url to asset.
+ #
+ # NOTE: This helper is currently not implemented and should be
+ # customized by the application. Though, in the future, some
+ # basics implemention may be provided with different methods that
+ # are required to be overridden.
+ def asset_path(path, options = {})
+ message = <<-EOS
+Custom asset_path helper is not implemented
+
+Extend your environment context with a custom method.
+
+ environment.context_class.class_eval do
+ def asset_path(path, options = {})
+ end
+ end
+ EOS
+ raise NotImplementedError, message
+ end
+
+ # Expand logical image asset path.
+ def image_path(path)
+ asset_path(path, :type => :image)
+ end
+
+ # Expand logical video asset path.
+ def video_path(path)
+ asset_path(path, :type => :video)
+ end
+
+ # Expand logical audio asset path.
+ def audio_path(path)
+ asset_path(path, :type => :audio)
+ end
+
+ # Expand logical font asset path.
+ def font_path(path)
+ asset_path(path, :type => :font)
+ end
+
+ # Expand logical javascript asset path.
+ def javascript_path(path)
+ asset_path(path, :type => :javascript)
+ end
+
+ # Expand logical stylesheet asset path.
+ def stylesheet_path(path)
+ asset_path(path, :type => :stylesheet)
+ end
+
+ private
+ # Annotates exception backtrace with the original template that
+ # the exception was raised in.
+ def annotate_exception!(exception)
+ location = pathname.to_s
+ location << ":#{@__LINE__}" if @__LINE__
+
+ exception.extend(Sprockets::EngineError)
+ exception.sprockets_annotation = " (in #{location})"
+ end
+
+ def logger
+ environment.logger
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/directive_processor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/directive_processor.rb
new file mode 100644
index 0000000..5d29f32
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/directive_processor.rb
@@ -0,0 +1,408 @@
+require 'pathname'
+require 'shellwords'
+require 'tilt'
+require 'yaml'
+
+module Sprockets
+ # The `DirectiveProcessor` is responsible for parsing and evaluating
+ # directive comments in a source file.
+ #
+ # A directive comment starts with a comment prefix, followed by an "=",
+ # then the directive name, then any arguments.
+ #
+ # // JavaScript
+ # //= require "foo"
+ #
+ # # CoffeeScript
+ # #= require "bar"
+ #
+ # /* CSS
+ # *= require "baz"
+ # */
+ #
+ # The Processor is implemented as a `Tilt::Template` and is loosely
+ # coupled to Sprockets. This makes it possible to disable or modify
+ # the processor to do whatever you'd like. You could add your own
+ # custom directives or invent your own directive syntax.
+ #
+ # `Environment#processors` includes `DirectiveProcessor` by default.
+ #
+ # To remove the processor entirely:
+ #
+ # env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
+ # env.unregister_processor('application/javascript', Sprockets::DirectiveProcessor)
+ #
+ # Then inject your own preprocessor:
+ #
+ # env.register_processor('text/css', MyProcessor)
+ #
+ class DirectiveProcessor < Tilt::Template
+ # Directives will only be picked up if they are in the header
+ # of the source file. C style (/* */), JavaScript (//), and
+ # Ruby (#) comments are supported.
+ #
+ # Directives in comments after the first non-whitespace line
+ # of code will not be processed.
+ #
+ HEADER_PATTERN = /
+ \A (
+ (?m:\s*) (
+ (\/\* (?m:.*?) \*\/) |
+ (\#\#\# (?m:.*?) \#\#\#) |
+ (\/\/ .* \n?)+ |
+ (\# .* \n?)+
+ )
+ )+
+ /x
+
+ # Directives are denoted by a `=` followed by the name, then
+ # argument list.
+ #
+ # A few different styles are allowed:
+ #
+ # // =require foo
+ # //= require foo
+ # //= require "foo"
+ #
+ DIRECTIVE_PATTERN = /
+ ^ \W* = \s* (\w+.*?) (\*\/)? $
+ /x
+
+ attr_reader :pathname
+ attr_reader :header, :body
+
+ def prepare
+ @pathname = Pathname.new(file)
+
+ @header = data[HEADER_PATTERN, 0] || ""
+ @body = $' || data
+ # Ensure body ends in a new line
+ @body += "\n" if @body != "" && @body !~ /\n\Z/m
+
+ @included_pathnames = []
+ @compat = false
+ end
+
+ # Implemented for Tilt#render.
+ #
+ # `context` is a `Context` instance with methods that allow you to
+ # access the environment and append to the bundle. See `Context`
+ # for the complete API.
+ def evaluate(context, locals, &block)
+ @context = context
+
+ @result = ""
+ @result.force_encoding(body.encoding) if body.respond_to?(:encoding)
+
+ @has_written_body = false
+
+ process_directives
+ process_source
+
+ @result
+ end
+
+ # Returns the header String with any directives stripped.
+ def processed_header
+ lineno = 0
+ @processed_header ||= header.lines.map { |line|
+ lineno += 1
+ # Replace directive line with a clean break
+ directives.assoc(lineno) ? "\n" : line
+ }.join.chomp
+ end
+
+ # Returns the source String with any directives stripped.
+ def processed_source
+ @processed_source ||= processed_header + body
+ end
+
+ # Returns an Array of directive structures. Each structure
+ # is an Array with the line number as the first element, the
+ # directive name as the second element, followed by any
+ # arguments.
+ #
+ # [[1, "require", "foo"], [2, "require", "bar"]]
+ #
+ def directives
+ @directives ||= header.lines.each_with_index.map { |line, index|
+ if directive = line[DIRECTIVE_PATTERN, 1]
+ name, *args = Shellwords.shellwords(directive)
+ if respond_to?("process_#{name}_directive", true)
+ [index + 1, name, *args]
+ end
+ end
+ }.compact
+ end
+
+ protected
+ attr_reader :included_pathnames
+ attr_reader :context
+
+ # Gathers comment directives in the source and processes them.
+ # Any directive method matching `process_*_directive` will
+ # automatically be available. This makes it easy to extend the
+ # processor.
+ #
+ # To implement a custom directive called `require_glob`, subclass
+ # `Sprockets::DirectiveProcessor`, then add a method called
+ # `process_require_glob_directive`.
+ #
+ # class DirectiveProcessor < Sprockets::DirectiveProcessor
+ # def process_require_glob_directive
+ # Dir["#{pathname.dirname}/#{glob}"].sort.each do |filename|
+ # require(filename)
+ # end
+ # end
+ # end
+ #
+ # Replace the current processor on the environment with your own:
+ #
+ # env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
+ # env.register_processor('text/css', DirectiveProcessor)
+ #
+ def process_directives
+ directives.each do |line_number, name, *args|
+ context.__LINE__ = line_number
+ send("process_#{name}_directive", *args)
+ context.__LINE__ = nil
+ end
+ end
+
+ def process_source
+ unless @has_written_body || processed_header.empty?
+ @result << processed_header << "\n"
+ end
+
+ included_pathnames.each do |pathname|
+ @result << context.evaluate(pathname)
+ end
+
+ unless @has_written_body
+ @result << body
+ end
+
+ if compat? && constants.any?
+ @result.gsub!(/<%=(.*?)%>/) { constants[$1.strip] }
+ end
+ end
+
+ # The `require` directive functions similar to Ruby's own `require`.
+ # It provides a way to declare a dependency on a file in your path
+ # and ensures its only loaded once before the source file.
+ #
+ # `require` works with files in the environment path:
+ #
+ # //= require "foo.js"
+ #
+ # Extensions are optional. If your source file is ".js", it
+ # assumes you are requiring another ".js".
+ #
+ # //= require "foo"
+ #
+ # Relative paths work too. Use a leading `./` to denote a relative
+ # path:
+ #
+ # //= require "./bar"
+ #
+ def process_require_directive(path)
+ if @compat
+ if path =~ /<([^>]+)>/
+ path = $1
+ else
+ path = "./#{path}" unless relative?(path)
+ end
+ end
+
+ context.require_asset(path)
+ end
+
+ # `require_self` causes the body of the current file to be
+ # inserted before any subsequent `require` or `include`
+ # directives. Useful in CSS files, where it's common for the
+ # index file to contain global styles that need to be defined
+ # before other dependencies are loaded.
+ #
+ # /*= require "reset"
+ # *= require_self
+ # *= require_tree .
+ # */
+ #
+ def process_require_self_directive
+ if @has_written_body
+ raise ArgumentError, "require_self can only be called once per source file"
+ end
+
+ context.require_asset(pathname)
+ process_source
+ included_pathnames.clear
+ @has_written_body = true
+ end
+
+ # The `include` directive works similar to `require` but
+ # inserts the contents of the dependency even if it already
+ # has been required.
+ #
+ # //= include "header"
+ #
+ def process_include_directive(path)
+ pathname = context.resolve(path)
+ context.depend_on_asset(pathname)
+ included_pathnames << pathname
+ end
+
+ # `require_directory` requires all the files inside a single
+ # directory. It's similar to `path/*` since it does not follow
+ # nested directories.
+ #
+ # //= require_directory "./javascripts"
+ #
+ def process_require_directory_directive(path = ".")
+ if relative?(path)
+ root = pathname.dirname.join(path).expand_path
+
+ unless (stats = stat(root)) && stats.directory?
+ raise ArgumentError, "require_directory argument must be a directory"
+ end
+
+ context.depend_on(root)
+
+ entries(root).each do |pathname|
+ pathname = root.join(pathname)
+ if pathname.to_s == self.file
+ next
+ elsif context.asset_requirable?(pathname)
+ context.require_asset(pathname)
+ end
+ end
+ else
+ # The path must be relative and start with a `./`.
+ raise ArgumentError, "require_directory argument must be a relative path"
+ end
+ end
+
+ # `require_tree` requires all the nested files in a directory.
+ # Its glob equivalent is `path/**/*`.
+ #
+ # //= require_tree "./public"
+ #
+ def process_require_tree_directive(path = ".")
+ if relative?(path)
+ root = pathname.dirname.join(path).expand_path
+
+ unless (stats = stat(root)) && stats.directory?
+ raise ArgumentError, "require_tree argument must be a directory"
+ end
+
+ context.depend_on(root)
+
+ each_entry(root) do |pathname|
+ if pathname.to_s == self.file
+ next
+ elsif stat(pathname).directory?
+ context.depend_on(pathname)
+ elsif context.asset_requirable?(pathname)
+ context.require_asset(pathname)
+ end
+ end
+ else
+ # The path must be relative and start with a `./`.
+ raise ArgumentError, "require_tree argument must be a relative path"
+ end
+ end
+
+ # Allows you to state a dependency on a file without
+ # including it.
+ #
+ # This is used for caching purposes. Any changes made to
+ # the dependency file will invalidate the cache of the
+ # source file.
+ #
+ # This is useful if you are using ERB and File.read to pull
+ # in contents from another file.
+ #
+ # //= depend_on "foo.png"
+ #
+ def process_depend_on_directive(path)
+ context.depend_on(path)
+ end
+
+ # Allows you to state a dependency on an asset without including
+ # it.
+ #
+ # This is used for caching purposes. Any changes that would
+ # invalid the asset dependency will invalidate the cache our the
+ # source file.
+ #
+ # Unlike `depend_on`, the path must be a requirable asset.
+ #
+ # //= depend_on_asset "bar.js"
+ #
+ def process_depend_on_asset_directive(path)
+ context.depend_on_asset(path)
+ end
+
+ # Allows dependency to be excluded from the asset bundle.
+ #
+ # The `path` must be a valid asset and may or may not already
+ # be part of the bundle. Once stubbed, it is blacklisted and
+ # can't be brought back by any other `require`.
+ #
+ # //= stub "jquery"
+ #
+ def process_stub_directive(path)
+ context.stub_asset(path)
+ end
+
+ # Enable Sprockets 1.x compat mode.
+ #
+ # Makes it possible to use the same JavaScript source
+ # file in both Sprockets 1 and 2.
+ #
+ # //= compat
+ #
+ def process_compat_directive
+ @compat = true
+ end
+
+ # Checks if Sprockets 1.x compat mode enabled
+ def compat?
+ @compat
+ end
+
+ # Sprockets 1.x allowed for constant interpolation if a
+ # constants.yml was present. This is only available if
+ # compat mode is on.
+ def constants
+ if compat?
+ pathname = Pathname.new(context.root_path).join("constants.yml")
+ stat(pathname) ? YAML.load_file(pathname) : {}
+ else
+ {}
+ end
+ end
+
+ # `provide` is stubbed out for Sprockets 1.x compat.
+ # Mutating the path when an asset is being built is
+ # not permitted.
+ def process_provide_directive(path)
+ end
+
+ private
+ def relative?(path)
+ path =~ /^\.($|\.?\/)/
+ end
+
+ def stat(path)
+ context.environment.stat(path)
+ end
+
+ def entries(path)
+ context.environment.entries(path)
+ end
+
+ def each_entry(root, &block)
+ context.environment.each_entry(root, &block)
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/eco_template.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/eco_template.rb
new file mode 100644
index 0000000..da003cc
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/eco_template.rb
@@ -0,0 +1,38 @@
+require 'tilt'
+
+module Sprockets
+ # Tilt engine class for the Eco compiler. Depends on the `eco` gem.
+ #
+ # For more infomation see:
+ #
+ # https://github.com/sstephenson/ruby-eco
+ # https://github.com/sstephenson/eco
+ #
+ class EcoTemplate < Tilt::Template
+ # Check to see if Eco is loaded
+ def self.engine_initialized?
+ defined? ::Eco
+ end
+
+ # Autoload eco library. If the library isn't loaded, Tilt will produce
+ # a thread safetly warning. If you intend to use `.eco` files, you
+ # should explicitly require it.
+ def initialize_engine
+ require_template_library 'eco'
+ end
+
+ def prepare
+ end
+
+ # Compile template data with Eco compiler.
+ #
+ # Returns a JS function definition String. The result should be
+ # assigned to a JS variable.
+ #
+ # # => "function(...) {...}"
+ #
+ def evaluate(scope, locals, &block)
+ Eco.compile(data)
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/ejs_template.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/ejs_template.rb
new file mode 100644
index 0000000..65ddaa6
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/ejs_template.rb
@@ -0,0 +1,37 @@
+require 'tilt'
+
+module Sprockets
+ # Tilt engine class for the EJS compiler. Depends on the `ejs` gem.
+ #
+ # For more infomation see:
+ #
+ # https://github.com/sstephenson/ruby-ejs
+ #
+ class EjsTemplate < Tilt::Template
+ # Check to see if EJS is loaded
+ def self.engine_initialized?
+ defined? ::EJS
+ end
+
+ # Autoload ejs library. If the library isn't loaded, Tilt will produce
+ # a thread safetly warning. If you intend to use `.ejs` files, you
+ # should explicitly require it.
+ def initialize_engine
+ require_template_library 'ejs'
+ end
+
+ def prepare
+ end
+
+ # Compile template data with EJS compiler.
+ #
+ # Returns a JS function definition String. The result should be
+ # assigned to a JS variable.
+ #
+ # # => "function(obj){...}"
+ #
+ def evaluate(scope, locals, &block)
+ EJS.compile(data)
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/engines.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/engines.rb
new file mode 100644
index 0000000..6a5b28f
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/engines.rb
@@ -0,0 +1,74 @@
+require 'sprockets/eco_template'
+require 'sprockets/ejs_template'
+require 'sprockets/jst_processor'
+require 'sprockets/utils'
+require 'tilt'
+
+module Sprockets
+ # `Engines` provides a global and `Environment` instance registry.
+ #
+ # An engine is a type of processor that is bound to an filename
+ # extension. `application.js.coffee` indicates that the
+ # `CoffeeScriptTemplate` engine will be ran on the file.
+ #
+ # Extensions can be stacked and will be evaulated from right to
+ # left. `application.js.coffee.erb` will first run `ERBTemplate`
+ # then `CoffeeScriptTemplate`.
+ #
+ # All `Engine`s must follow the `Tilt::Template` interface. It is
+ # recommended to subclass `Tilt::Template`.
+ #
+ # Its recommended that you register engine changes on your local
+ # `Environment` instance.
+ #
+ # environment.register_engine '.foo', FooProcessor
+ #
+ # The global registry is exposed for plugins to register themselves.
+ #
+ # Sprockets.register_engine '.sass', SassTemplate
+ #
+ module Engines
+ # Returns a `Hash` of `Engine`s registered on the `Environment`.
+ # If an `ext` argument is supplied, the `Engine` associated with
+ # that extension will be returned.
+ #
+ # environment.engines
+ # # => {".coffee" => CoffeeScriptTemplate, ".sass" => SassTemplate, ...}
+ #
+ # environment.engines('.coffee')
+ # # => CoffeeScriptTemplate
+ #
+ def engines(ext = nil)
+ if ext
+ ext = Sprockets::Utils.normalize_extension(ext)
+ @engines[ext]
+ else
+ @engines.dup
+ end
+ end
+
+ # Returns an `Array` of engine extension `String`s.
+ #
+ # environment.engine_extensions
+ # # => ['.coffee', '.sass', ...]
+ def engine_extensions
+ @engines.keys
+ end
+
+ # Registers a new Engine `klass` for `ext`. If the `ext` already
+ # has an engine registered, it will be overridden.
+ #
+ # environment.register_engine '.coffee', CoffeeScriptTemplate
+ #
+ def register_engine(ext, klass)
+ ext = Sprockets::Utils.normalize_extension(ext)
+ @engines[ext] = klass
+ end
+
+ private
+ def deep_copy_hash(hash)
+ initial = Hash.new { |h, k| h[k] = [] }
+ hash.inject(initial) { |h, (k, a)| h[k] = a.dup; h }
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/environment.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/environment.rb
new file mode 100644
index 0000000..874c66a
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/environment.rb
@@ -0,0 +1,88 @@
+require 'sprockets/base'
+require 'sprockets/context'
+require 'sprockets/index'
+
+require 'hike'
+require 'logger'
+require 'pathname'
+require 'tilt'
+
+module Sprockets
+ class Environment < Base
+ # `Environment` should initialized with your application's root
+ # directory. This should be the same as your Rails or Rack root.
+ #
+ # env = Environment.new(Rails.root)
+ #
+ def initialize(root = ".")
+ @trail = Hike::Trail.new(root)
+
+ self.logger = Logger.new($stderr)
+ self.logger.level = Logger::FATAL
+
+ if respond_to?(:default_external_encoding)
+ self.default_external_encoding = Encoding::UTF_8
+ end
+
+ # Create a safe `Context` subclass to mutate
+ @context_class = Class.new(Context)
+
+ # Set MD5 as the default digest
+ require 'digest/md5'
+ @digest_class = ::Digest::MD5
+ @version = ''
+
+ @mime_types = Sprockets.registered_mime_types
+ @engines = Sprockets.engines
+ @preprocessors = Sprockets.preprocessors
+ @postprocessors = Sprockets.postprocessors
+ @bundle_processors = Sprockets.bundle_processors
+ @compressors = Sprockets.compressors
+
+ Sprockets.paths.each do |path|
+ append_path(path)
+ end
+
+ @engines.each do |ext, klass|
+ add_engine_to_trail(ext, klass)
+ end
+
+ @mime_types.each do |ext, type|
+ @trail.append_extension(ext)
+ end
+
+ expire_index!
+
+ yield self if block_given?
+ end
+
+ # Returns a cached version of the environment.
+ #
+ # All its file system calls are cached which makes `index` much
+ # faster. This behavior is ideal in production since the file
+ # system only changes between deploys.
+ def index
+ Index.new(self)
+ end
+
+ # Cache `find_asset` calls
+ def find_asset(path, options = {})
+ options[:bundle] = true unless options.key?(:bundle)
+
+ # Ensure inmemory cached assets are still fresh on every lookup
+ if (asset = @assets[cache_key_for(path, options)]) && asset.fresh?(self)
+ asset
+ elsif asset = index.find_asset(path, options)
+ # Cache is pushed upstream by Index#find_asset
+ asset
+ end
+ end
+
+ protected
+ def expire_index!
+ # Clear digest to be recomputed
+ @digest = nil
+ @assets = {}
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/errors.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/errors.rb
new file mode 100644
index 0000000..f7a00c4
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/errors.rb
@@ -0,0 +1,20 @@
+# Define some basic Sprockets error classes
+module Sprockets
+ class Error < StandardError; end
+ class ArgumentError < Error; end
+ class CircularDependencyError < Error; end
+ class ContentTypeMismatch < Error; end
+ class EncodingError < Error; end
+ class FileNotFound < Error; end
+ class FileOutsidePaths < Error; end
+ class NotImplementedError < Error; end
+ class UnserializeError < Error; end
+
+ module EngineError
+ attr_accessor :sprockets_annotation
+
+ def message
+ [super, sprockets_annotation].compact.join("\n")
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/index.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/index.rb
new file mode 100644
index 0000000..8aa6ad6
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/index.rb
@@ -0,0 +1,100 @@
+require 'sprockets/base'
+
+module Sprockets
+ # `Index` is a special cached version of `Environment`.
+ #
+ # The expection is that all of its file system methods are cached
+ # for the instances lifetime. This makes `Index` much faster. This
+ # behavior is ideal in production environments where the file system
+ # is immutable.
+ #
+ # `Index` should not be initialized directly. Instead use
+ # `Environment#index`.
+ class Index < Base
+ def initialize(environment)
+ @environment = environment
+
+ if environment.respond_to?(:default_external_encoding)
+ @default_external_encoding = environment.default_external_encoding
+ end
+
+ # Copy environment attributes
+ @logger = environment.logger
+ @context_class = environment.context_class
+ @cache = environment.cache
+ @trail = environment.trail.index
+ @digest = environment.digest
+ @digest_class = environment.digest_class
+ @version = environment.version
+ @mime_types = environment.mime_types
+ @engines = environment.engines
+ @preprocessors = environment.preprocessors
+ @postprocessors = environment.postprocessors
+ @bundle_processors = environment.bundle_processors
+ @compressors = environment.compressors
+
+ # Initialize caches
+ @assets = {}
+ @digests = {}
+ end
+
+ # No-op return self as index
+ def index
+ self
+ end
+
+ # Cache calls to `file_digest`
+ def file_digest(pathname)
+ key = pathname.to_s
+ if @digests.key?(key)
+ @digests[key]
+ else
+ @digests[key] = super
+ end
+ end
+
+ # Cache `find_asset` calls
+ def find_asset(path, options = {})
+ options[:bundle] = true unless options.key?(:bundle)
+ if asset = @assets[cache_key_for(path, options)]
+ asset
+ elsif asset = super
+ logical_path_cache_key = cache_key_for(path, options)
+ full_path_cache_key = cache_key_for(asset.pathname, options)
+
+ # Cache on Index
+ @assets[logical_path_cache_key] = @assets[full_path_cache_key] = asset
+
+ # Push cache upstream to Environment
+ @environment.instance_eval do
+ @assets[logical_path_cache_key] = @assets[full_path_cache_key] = asset
+ end
+
+ asset
+ end
+ end
+
+ protected
+ # Index is immutable, any methods that try to clear the cache
+ # should bomb.
+ def expire_index!
+ raise TypeError, "can't modify immutable index"
+ end
+
+ # Cache asset building in memory and in persisted cache.
+ def build_asset(path, pathname, options)
+ # Memory cache
+ key = cache_key_for(pathname, options)
+ if @assets.key?(key)
+ @assets[key]
+ else
+ @assets[key] = begin
+ # Persisted cache
+ cache_asset(key) do
+ super
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/jst_processor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/jst_processor.rb
new file mode 100644
index 0000000..4d85915
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/jst_processor.rb
@@ -0,0 +1,29 @@
+require 'tilt'
+
+module Sprockets
+ class JstProcessor < Tilt::Template
+ self.default_mime_type = 'application/javascript'
+
+ def self.default_namespace
+ 'this.JST'
+ end
+
+ def prepare
+ @namespace = self.class.default_namespace
+ end
+
+ attr_reader :namespace
+
+ def evaluate(scope, locals, &block)
+ <<-JST
+(function() { #{namespace} || (#{namespace} = {}); #{namespace}[#{scope.logical_path.inspect}] = #{indent(data)};
+}).call(this);
+ JST
+ end
+
+ private
+ def indent(string)
+ string.gsub(/$(.)/m, "\\1 ").strip
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/manifest.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/manifest.rb
new file mode 100644
index 0000000..aa19068
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/manifest.rb
@@ -0,0 +1,261 @@
+require 'multi_json'
+require 'securerandom'
+require 'time'
+
+module Sprockets
+ # The Manifest logs the contents of assets compiled to a single
+ # directory. It records basic attributes about the asset for fast
+ # lookup without having to compile. A pointer from each logical path
+ # indicates with fingerprinted asset is the current one.
+ #
+ # The JSON is part of the public API and should be considered
+ # stable. This should make it easy to read from other programming
+ # languages and processes that don't have sprockets loaded. See
+ # `#assets` and `#files` for more infomation about the structure.
+ class Manifest
+ attr_reader :environment, :path, :dir
+
+ # Create new Manifest associated with an `environment`. `path` is
+ # a full path to the manifest json file. The file may or may not
+ # already exist. The dirname of the `path` will be used to write
+ # compiled assets to. Otherwise, if the path is a directory, the
+ # filename will default a random "manifest-123.json" file in that
+ # directory.
+ #
+ # Manifest.new(environment, "./public/assets/manifest.json")
+ #
+ def initialize(*args)
+ if args.first.is_a?(Base) || args.first.nil?
+ @environment = args.shift
+ end
+
+ @dir, @path = args[0], args[1]
+
+ # Expand paths
+ @dir = File.expand_path(@dir) if @dir
+ @path = File.expand_path(@path) if @path
+
+ # If path is given as the second arg
+ if @dir && File.extname(@dir) != ""
+ @dir, @path = nil, @dir
+ end
+
+ # Default dir to the directory of the path
+ @dir ||= File.dirname(@path) if @path
+
+ # If directory is given w/o path, pick a random manifest.json location
+ if @dir && @path.nil?
+ # Find the first manifest.json in the directory
+ paths = Dir[File.join(@dir, "manifest*.json")]
+ if paths.any?
+ @path = paths.first
+ else
+ @path = File.join(@dir, "manifest-#{SecureRandom.hex(16)}.json")
+ end
+ end
+
+ unless @dir && @path
+ raise ArgumentError, "manifest requires output path"
+ end
+
+ data = nil
+
+ begin
+ if File.exist?(@path)
+ data = json_decode(File.read(@path))
+ end
+ rescue MultiJson::DecodeError => e
+ logger.error "#{@path} is invalid: #{e.class} #{e.message}"
+ end
+
+ @data = data.is_a?(Hash) ? data : {}
+ end
+
+ # Returns internal assets mapping. Keys are logical paths which
+ # map to the latest fingerprinted filename.
+ #
+ # Logical path (String): Fingerprint path (String)
+ #
+ # { "application.js" => "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js",
+ # "jquery.js" => "jquery-ae0908555a245f8266f77df5a8edca2e.js" }
+ #
+ def assets
+ @data['assets'] ||= {}
+ end
+
+ # Returns internal file directory listing. Keys are filenames
+ # which map to an attributes array.
+ #
+ # Fingerprint path (String):
+ # logical_path: Logical path (String)
+ # mtime: ISO8601 mtime (String)
+ # digest: Base64 hex digest (String)
+ #
+ # { "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js" =>
+ # { 'logical_path' => "application.js",
+ # 'mtime' => "2011-12-13T21:47:08-06:00",
+ # 'digest' => "2e8e9a7c6b0aafa0c9bdeec90ea30213" } }
+ #
+ def files
+ @data['files'] ||= {}
+ end
+
+ # Compile and write asset to directory. The asset is written to a
+ # fingerprinted filename like
+ # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
+ # also inserted into the manifest file.
+ #
+ # compile("application.js")
+ #
+ def compile(*args)
+ unless environment
+ raise Error, "manifest requires environment for compilation"
+ end
+
+ paths = environment.each_logical_path(*args).to_a +
+ args.flatten.select { |fn| Pathname.new(fn).absolute? if fn.is_a?(String)}
+
+ paths.each do |path|
+ if asset = find_asset(path)
+ files[asset.digest_path] = {
+ 'logical_path' => asset.logical_path,
+ 'mtime' => asset.mtime.iso8601,
+ 'size' => asset.bytesize,
+ 'digest' => asset.digest
+ }
+ assets[asset.logical_path] = asset.digest_path
+
+ target = File.join(dir, asset.digest_path)
+
+ if File.exist?(target)
+ logger.debug "Skipping #{target}, already exists"
+ else
+ logger.info "Writing #{target}"
+ asset.write_to target
+ asset.write_to "#{target}.gz" if asset.is_a?(BundledAsset)
+ end
+
+ end
+ end
+ save
+ paths
+ end
+
+ # Removes file from directory and from manifest. `filename` must
+ # be the name with any directory path.
+ #
+ # manifest.remove("application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js")
+ #
+ def remove(filename)
+ path = File.join(dir, filename)
+ gzip = "#{path}.gz"
+ logical_path = files[filename]['logical_path']
+
+ if assets[logical_path] == filename
+ assets.delete(logical_path)
+ end
+
+ files.delete(filename)
+ FileUtils.rm(path) if File.exist?(path)
+ FileUtils.rm(gzip) if File.exist?(gzip)
+
+ save
+
+ logger.info "Removed #{filename}"
+
+ nil
+ end
+
+ # Cleanup old assets in the compile directory. By default it will
+ # keep the latest version plus 2 backups.
+ def clean(keep = 2)
+ self.assets.keys.each do |logical_path|
+ # Get assets sorted by ctime, newest first
+ assets = backups_for(logical_path)
+
+ # Keep the last N backups
+ assets = assets[keep..-1] || []
+
+ # Remove old assets
+ assets.each { |path, _| remove(path) }
+ end
+ end
+
+ # Wipe directive
+ def clobber
+ FileUtils.rm_r(@dir) if File.exist?(@dir)
+ logger.info "Removed #{@dir}"
+ nil
+ end
+
+ protected
+ # Finds all the backup assets for a logical path. The latest
+ # version is always excluded. The return array is sorted by the
+ # assets mtime in descending order (Newest to oldest).
+ def backups_for(logical_path)
+ files.select { |filename, attrs|
+ # Matching logical paths
+ attrs['logical_path'] == logical_path &&
+ # Excluding whatever asset is the current
+ assets[logical_path] != filename
+ }.sort_by { |filename, attrs|
+ # Sort by timestamp
+ Time.parse(attrs['mtime'])
+ }.reverse
+ end
+
+ # Basic wrapper around Environment#find_asset. Logs compile time.
+ def find_asset(logical_path)
+ asset = nil
+ ms = benchmark do
+ asset = environment.find_asset(logical_path)
+ end
+ logger.debug "Compiled #{logical_path} (#{ms}ms)"
+ asset
+ end
+
+ # Persist manfiest back to FS
+ def save
+ FileUtils.mkdir_p File.dirname(path)
+ File.open(path, 'w') do |f|
+ f.write json_encode(@data)
+ end
+ end
+
+ private
+ # Feature detect newer MultiJson API
+ if MultiJson.respond_to?(:dump)
+ def json_decode(obj)
+ MultiJson.load(obj)
+ end
+
+ def json_encode(obj)
+ MultiJson.dump(obj)
+ end
+ else
+ def json_decode(obj)
+ MultiJson.decode(obj)
+ end
+
+ def json_encode(obj)
+ MultiJson.encode(obj)
+ end
+ end
+
+ def logger
+ if environment
+ environment.logger
+ else
+ logger = Logger.new($stderr)
+ logger.level = Logger::FATAL
+ logger
+ end
+ end
+
+ def benchmark
+ start_time = Time.now.to_f
+ yield
+ ((Time.now.to_f - start_time) * 1000).to_i
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/mime.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/mime.rb
new file mode 100644
index 0000000..d4949bb
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/mime.rb
@@ -0,0 +1,49 @@
+require 'rack/mime'
+
+module Sprockets
+ module Mime
+ # Returns a `Hash` of registered mime types registered on the
+ # environment and those part of `Rack::Mime`.
+ #
+ # If an `ext` is given, it will lookup the mime type for that extension.
+ def mime_types(ext = nil)
+ if ext.nil?
+ Rack::Mime::MIME_TYPES.merge(@mime_types)
+ else
+ ext = Sprockets::Utils.normalize_extension(ext)
+ @mime_types[ext] || Rack::Mime::MIME_TYPES[ext]
+ end
+ end
+
+ # Returns a `Hash` of explicitly registered mime types.
+ def registered_mime_types
+ @mime_types.dup
+ end
+
+ if {}.respond_to?(:key)
+ def extension_for_mime_type(type)
+ mime_types.key(type)
+ end
+ else
+ def extension_for_mime_type(type)
+ mime_types.index(type)
+ end
+ end
+
+ # Register a new mime type.
+ def register_mime_type(mime_type, ext)
+ ext = Sprockets::Utils.normalize_extension(ext)
+ @mime_types[ext] = mime_type
+ end
+
+ if defined? Encoding
+ # Returns the correct encoding for a given mime type, while falling
+ # back on the default external encoding, if it exists.
+ def encoding_for_mime_type(type)
+ encoding = Encoding::BINARY if type =~ %r{^(image|audio|video)/}
+ encoding ||= default_external_encoding if respond_to?(:default_external_encoding)
+ encoding
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/paths.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/paths.rb
new file mode 100644
index 0000000..f17b801
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/paths.rb
@@ -0,0 +1,58 @@
+module Sprockets
+ module Paths
+ # Returns `Environment` root.
+ #
+ # All relative paths are expanded with root as its base. To be
+ # useful set this to your applications root directory. (`Rails.root`)
+ def root
+ @trail.root.dup
+ end
+
+ # Returns an `Array` of path `String`s.
+ #
+ # These paths will be used for asset logical path lookups.
+ #
+ # Note that a copy of the `Array` is returned so mutating will
+ # have no affect on the environment. See `append_path`,
+ # `prepend_path`, and `clear_paths`.
+ def paths
+ @trail.paths.dup
+ end
+
+ # Prepend a `path` to the `paths` list.
+ #
+ # Paths at the end of the `Array` have the least priority.
+ def prepend_path(path)
+ @trail.prepend_path(path)
+ end
+
+ # Append a `path` to the `paths` list.
+ #
+ # Paths at the beginning of the `Array` have a higher priority.
+ def append_path(path)
+ @trail.append_path(path)
+ end
+
+ # Clear all paths and start fresh.
+ #
+ # There is no mechanism for reordering paths, so its best to
+ # completely wipe the paths list and reappend them in the order
+ # you want.
+ def clear_paths
+ @trail.paths.dup.each { |path| @trail.remove_path(path) }
+ end
+
+ # Returns an `Array` of extensions.
+ #
+ # These extensions maybe omitted from logical path searches.
+ #
+ # # => [".js", ".css", ".coffee", ".sass", ...]
+ #
+ def extensions
+ @trail.extensions.dup
+ end
+
+ protected
+ attr_reader :trail
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processed_asset.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processed_asset.rb
new file mode 100644
index 0000000..1793675
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processed_asset.rb
@@ -0,0 +1,152 @@
+require 'sprockets/asset'
+require 'sprockets/utils'
+
+module Sprockets
+ class ProcessedAsset < Asset
+ def initialize(environment, logical_path, pathname)
+ super
+
+ start_time = Time.now.to_f
+
+ context = environment.context_class.new(environment, logical_path, pathname)
+ @source = context.evaluate(pathname)
+ @length = Rack::Utils.bytesize(source)
+ @digest = environment.digest.update(source).hexdigest
+
+ build_required_assets(environment, context)
+ build_dependency_paths(environment, context)
+
+ @dependency_digest = compute_dependency_digest(environment)
+
+ elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
+ environment.logger.debug "Compiled #{logical_path} (#{elapsed_time}ms) (pid #{Process.pid})"
+ end
+
+ # Interal: Used to check equality
+ attr_reader :dependency_digest
+
+ attr_reader :source
+
+ # Initialize `BundledAsset` from serialized `Hash`.
+ def init_with(environment, coder)
+ super
+
+ @source = coder['source']
+ @dependency_digest = coder['dependency_digest']
+
+ @required_assets = coder['required_paths'].map { |p|
+ p = expand_root_path(p)
+
+ unless environment.paths.detect { |path| p[path] }
+ raise UnserializeError, "#{p} isn't in paths"
+ end
+
+ p == pathname.to_s ? self : environment.find_asset(p, :bundle => false)
+ }
+ @dependency_paths = coder['dependency_paths'].map { |h|
+ DependencyFile.new(expand_root_path(h['path']), h['mtime'], h['digest'])
+ }
+ end
+
+ # Serialize custom attributes in `BundledAsset`.
+ def encode_with(coder)
+ super
+
+ coder['source'] = source
+ coder['dependency_digest'] = dependency_digest
+
+ coder['required_paths'] = required_assets.map { |a|
+ relativize_root_path(a.pathname).to_s
+ }
+ coder['dependency_paths'] = dependency_paths.map { |d|
+ { 'path' => relativize_root_path(d.pathname).to_s,
+ 'mtime' => d.mtime.iso8601,
+ 'digest' => d.digest }
+ }
+ end
+
+ # Checks if Asset is stale by comparing the actual mtime and
+ # digest to the inmemory model.
+ def fresh?(environment)
+ # Check freshness of all declared dependencies
+ @dependency_paths.all? { |dep| dependency_fresh?(environment, dep) }
+ end
+
+ protected
+ class DependencyFile < Struct.new(:pathname, :mtime, :digest)
+ def initialize(pathname, mtime, digest)
+ pathname = Pathname.new(pathname) unless pathname.is_a?(Pathname)
+ mtime = Time.parse(mtime) if mtime.is_a?(String)
+ super
+ end
+
+ def eql?(other)
+ other.is_a?(DependencyFile) &&
+ pathname.eql?(other.pathname) &&
+ mtime.eql?(other.mtime) &&
+ digest.eql?(other.digest)
+ end
+
+ def hash
+ pathname.to_s.hash
+ end
+ end
+
+ private
+ def build_required_assets(environment, context)
+ @required_assets = resolve_dependencies(environment, context._required_paths + [pathname.to_s]) -
+ resolve_dependencies(environment, context._stubbed_assets.to_a)
+ end
+
+ def resolve_dependencies(environment, paths)
+ assets = []
+ cache = {}
+
+ paths.each do |path|
+ if path == self.pathname.to_s
+ unless cache[self]
+ cache[self] = true
+ assets << self
+ end
+ elsif asset = environment.find_asset(path, :bundle => false)
+ asset.required_assets.each do |asset_dependency|
+ unless cache[asset_dependency]
+ cache[asset_dependency] = true
+ assets << asset_dependency
+ end
+ end
+ end
+ end
+
+ assets
+ end
+
+ def build_dependency_paths(environment, context)
+ dependency_paths = {}
+
+ context._dependency_paths.each do |path|
+ dep = DependencyFile.new(path, environment.stat(path).mtime, environment.file_digest(path).hexdigest)
+ dependency_paths[dep] = true
+ end
+
+ context._dependency_assets.each do |path|
+ if path == self.pathname.to_s
+ dep = DependencyFile.new(pathname, environment.stat(path).mtime, environment.file_digest(path).hexdigest)
+ dependency_paths[dep] = true
+ elsif asset = environment.find_asset(path, :bundle => false)
+ asset.dependency_paths.each do |d|
+ dependency_paths[d] = true
+ end
+ end
+ end
+
+ @dependency_paths = dependency_paths.keys
+ end
+
+ def compute_dependency_digest(environment)
+ required_assets.inject(environment.digest) { |digest, asset|
+ digest.update asset.digest
+ }.hexdigest
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processing.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processing.rb
new file mode 100644
index 0000000..6b20086
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processing.rb
@@ -0,0 +1,206 @@
+require 'sprockets/engines'
+require 'sprockets/mime'
+require 'sprockets/processor'
+require 'sprockets/utils'
+
+module Sprockets
+ # `Processing` is an internal mixin whose public methods are exposed on
+ # the `Environment` and `Index` classes.
+ module Processing
+ # Returns an `Array` of format extension `String`s.
+ #
+ # format_extensions
+ # # => ['.js', '.css']
+ #
+ def format_extensions
+ @trail.extensions - @engines.keys
+ end
+
+ # Deprecated alias for `preprocessors`.
+ def processors(*args)
+ preprocessors(*args)
+ end
+
+ # Returns an `Array` of `Processor` classes. If a `mime_type`
+ # argument is supplied, the processors registered under that
+ # extension will be returned.
+ #
+ # Preprocessors are ran before Postprocessors and Engine
+ # processors.
+ #
+ # All `Processor`s must follow the `Tilt::Template` interface. It is
+ # recommended to subclass `Tilt::Template`.
+ def preprocessors(mime_type = nil)
+ if mime_type
+ @preprocessors[mime_type].dup
+ else
+ deep_copy_hash(@preprocessors)
+ end
+ end
+
+ # Returns an `Array` of `Processor` classes. If a `mime_type`
+ # argument is supplied, the processors registered under that
+ # extension will be returned.
+ #
+ # Postprocessors are ran after Preprocessors and Engine processors.
+ #
+ # All `Processor`s must follow the `Tilt::Template` interface. It is
+ # recommended to subclass `Tilt::Template`.
+ def postprocessors(mime_type = nil)
+ if mime_type
+ @postprocessors[mime_type].dup
+ else
+ deep_copy_hash(@postprocessors)
+ end
+ end
+
+ # Deprecated alias for `register_preprocessor`.
+ def register_processor(*args, &block)
+ register_preprocessor(*args, &block)
+ end
+
+ # Registers a new Preprocessor `klass` for `mime_type`.
+ #
+ # register_preprocessor 'text/css', Sprockets::DirectiveProcessor
+ #
+ # A block can be passed for to create a shorthand processor.
+ #
+ # register_preprocessor 'text/css', :my_processor do |context, data|
+ # data.gsub(...)
+ # end
+ #
+ def register_preprocessor(mime_type, klass, &block)
+ if block_given?
+ name = klass.to_s
+ klass = Class.new(Processor) do
+ @name = name
+ @processor = block
+ end
+ end
+
+ @preprocessors[mime_type].push(klass)
+ end
+
+ # Registers a new Postprocessor `klass` for `mime_type`.
+ #
+ # register_postprocessor 'text/css', Sprockets::CharsetNormalizer
+ #
+ # A block can be passed for to create a shorthand processor.
+ #
+ # register_postprocessor 'text/css', :my_processor do |context, data|
+ # data.gsub(...)
+ # end
+ #
+ def register_postprocessor(mime_type, klass, &block)
+ if block_given?
+ name = klass.to_s
+ klass = Class.new(Processor) do
+ @name = name
+ @processor = block
+ end
+ end
+
+ @postprocessors[mime_type].push(klass)
+ end
+
+ # Deprecated alias for `unregister_preprocessor`.
+ def unregister_processor(*args)
+ unregister_preprocessor(*args)
+ end
+
+ # Remove Preprocessor `klass` for `mime_type`.
+ #
+ # unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor
+ #
+ def unregister_preprocessor(mime_type, klass)
+ if klass.is_a?(String) || klass.is_a?(Symbol)
+ klass = @preprocessors[mime_type].detect { |cls|
+ cls.respond_to?(:name) &&
+ cls.name == "Sprockets::Processor (#{klass})"
+ }
+ end
+
+ @preprocessors[mime_type].delete(klass)
+ end
+
+ # Remove Postprocessor `klass` for `mime_type`.
+ #
+ # unregister_postprocessor 'text/css', Sprockets::DirectiveProcessor
+ #
+ def unregister_postprocessor(mime_type, klass)
+ if klass.is_a?(String) || klass.is_a?(Symbol)
+ klass = @postprocessors[mime_type].detect { |cls|
+ cls.respond_to?(:name) &&
+ cls.name == "Sprockets::Processor (#{klass})"
+ }
+ end
+
+ @postprocessors[mime_type].delete(klass)
+ end
+
+ # Returns an `Array` of `Processor` classes. If a `mime_type`
+ # argument is supplied, the processors registered under that
+ # extension will be returned.
+ #
+ # Bundle Processors are ran on concatenated assets rather than
+ # individual files.
+ #
+ # All `Processor`s must follow the `Tilt::Template` interface. It is
+ # recommended to subclass `Tilt::Template`.
+ def bundle_processors(mime_type = nil)
+ if mime_type
+ @bundle_processors[mime_type].dup
+ else
+ deep_copy_hash(@bundle_processors)
+ end
+ end
+
+ # Registers a new Bundle Processor `klass` for `mime_type`.
+ #
+ # register_bundle_processor 'text/css', Sprockets::CharsetNormalizer
+ #
+ # A block can be passed for to create a shorthand processor.
+ #
+ # register_bundle_processor 'text/css', :my_processor do |context, data|
+ # data.gsub(...)
+ # end
+ #
+ def register_bundle_processor(mime_type, klass, &block)
+ if block_given?
+ name = klass.to_s
+ klass = Class.new(Processor) do
+ @name = name
+ @processor = block
+ end
+ end
+
+ @bundle_processors[mime_type].push(klass)
+ end
+
+ # Remove Bundle Processor `klass` for `mime_type`.
+ #
+ # unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
+ #
+ def unregister_bundle_processor(mime_type, klass)
+ if klass.is_a?(String) || klass.is_a?(Symbol)
+ klass = @bundle_processors[mime_type].detect { |cls|
+ cls.respond_to?(:name) &&
+ cls.name == "Sprockets::Processor (#{klass})"
+ }
+ end
+
+ @bundle_processors[mime_type].delete(klass)
+ end
+
+ private
+ def add_engine_to_trail(ext, klass)
+ @trail.append_extension(ext.to_s)
+
+ if klass.respond_to?(:default_mime_type) && klass.default_mime_type
+ if format_ext = extension_for_mime_type(klass.default_mime_type)
+ @trail.alias_extension(ext.to_s, format_ext)
+ end
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processor.rb
new file mode 100644
index 0000000..c6dad06
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/processor.rb
@@ -0,0 +1,32 @@
+require 'tilt'
+
+module Sprockets
+ # `Processor` creates an anonymous processor class from a block.
+ #
+ # register_preprocessor 'text/css', :my_processor do |context, data|
+ # # ...
+ # end
+ #
+ class Processor < Tilt::Template
+ # `processor` is a lambda or block
+ def self.processor
+ @processor
+ end
+
+ def self.name
+ "Sprockets::Processor (#{@name})"
+ end
+
+ def self.to_s
+ name
+ end
+
+ def prepare
+ end
+
+ # Call processor block with `context` and `data`.
+ def evaluate(context, locals)
+ self.class.processor.call(context, data)
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/safety_colons.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/safety_colons.rb
new file mode 100644
index 0000000..19dcd59
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/safety_colons.rb
@@ -0,0 +1,28 @@
+require 'tilt'
+
+module Sprockets
+ # For JS developers who are colonfobic, concatenating JS files using
+ # the module pattern usually leads to syntax errors.
+ #
+ # The `SafetyColons` processor will insert missing semicolons to the
+ # end of the file.
+ #
+ # This behavior can be disabled with:
+ #
+ # environment.unregister_postprocessor 'application/javascript', Sprockets::SafetyColons
+ #
+ class SafetyColons < Tilt::Template
+ def prepare
+ end
+
+ def evaluate(context, locals, &block)
+ # If the file is blank or ends in a semicolon, leave it as is
+ if data =~ /\A\s*\Z/m || data =~ /;\s*\Z/m
+ data
+ else
+ # Otherwise, append a semicolon and newline
+ "#{data};\n"
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_cache_store.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_cache_store.rb
new file mode 100644
index 0000000..d969a5c
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_cache_store.rb
@@ -0,0 +1,29 @@
+require 'sass'
+
+module Sprockets
+ class SassCacheStore < ::Sass::CacheStores::Base
+ attr_reader :environment
+
+ def initialize(environment)
+ @environment = environment
+ end
+
+ def _store(key, version, sha, contents)
+ environment.cache_set("sass/#{key}", {:version => version, :sha => sha, :contents => contents})
+ end
+
+ def _retrieve(key, version, sha)
+ if obj = environment.cache_get("sass/#{key}")
+ return unless obj[:version] == version
+ return unless obj[:sha] == sha
+ obj[:contents]
+ else
+ nil
+ end
+ end
+
+ def path_to(key)
+ key
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_compressor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_compressor.rb
new file mode 100644
index 0000000..112d4ee
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_compressor.rb
@@ -0,0 +1,27 @@
+require 'tilt'
+
+module Sprockets
+ class SassCompressor < Tilt::Template
+ self.default_mime_type = 'text/css'
+
+ def self.engine_initialized?
+ defined?(::Sass::Engine)
+ end
+
+ def initialize_engine
+ require_template_library 'sass'
+ end
+
+ def prepare
+ end
+
+ def evaluate(context, locals, &block)
+ ::Sass::Engine.new(data, {
+ :syntax => :scss,
+ :cache => false,
+ :read_cache => false,
+ :style => :compressed
+ }).render
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_functions.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_functions.rb
new file mode 100644
index 0000000..59cd127
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_functions.rb
@@ -0,0 +1,70 @@
+require 'sass'
+
+module Sprockets
+ module SassFunctions
+ def asset_path(path)
+ ::Sass::Script::String.new(sprockets_context.asset_path(path.value), :string)
+ end
+
+ def asset_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.asset_path(path.value) + ")")
+ end
+
+ def image_path(path)
+ ::Sass::Script::String.new(sprockets_context.image_path(path.value), :string)
+ end
+
+ def image_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.image_path(path.value) + ")")
+ end
+
+ def video_path(path)
+ ::Sass::Script::String.new(sprockets_context.video_path(path.value), :string)
+ end
+
+ def video_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.video_path(path.value) + ")")
+ end
+
+ def audio_path(path)
+ ::Sass::Script::String.new(sprockets_context.audio_path(path.value), :string)
+ end
+
+ def audio_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.audio_path(path.value) + ")")
+ end
+
+ def font_path(path)
+ ::Sass::Script::String.new(sprockets_context.font_path(path.value), :string)
+ end
+
+ def font_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.font_path(path.value) + ")")
+ end
+
+ def javascript_path(path)
+ ::Sass::Script::String.new(sprockets_context.javascript_path(path.value), :string)
+ end
+
+ def javascript_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.javascript_path(path.value) + ")")
+ end
+
+ def stylesheet_path(path)
+ ::Sass::Script::String.new(sprockets_context.stylesheet_path(path.value), :string)
+ end
+
+ def stylesheet_url(path)
+ ::Sass::Script::String.new("url(" + sprockets_context.stylesheet_path(path.value) + ")")
+ end
+
+ protected
+ def sprockets_context
+ options[:sprockets][:context]
+ end
+
+ def sprockets_environment
+ options[:sprockets][:environment]
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_importer.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_importer.rb
new file mode 100644
index 0000000..3929500
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_importer.rb
@@ -0,0 +1,30 @@
+require 'sass'
+
+module Sprockets
+ # This custom importer that tracks all imported filenames during
+ # compile.
+ class SassImporter < ::Sass::Importers::Filesystem
+ attr_reader :imported_filenames
+
+ def initialize(*args)
+ @imported_filenames = []
+ super
+ end
+
+ def find_relative(*args)
+ engine = super
+ if engine && (filename = engine.options[:filename])
+ @imported_filenames << filename
+ end
+ engine
+ end
+
+ def find(*args)
+ engine = super
+ if engine && (filename = engine.options[:filename])
+ @imported_filenames << filename
+ end
+ engine
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_template.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_template.rb
new file mode 100644
index 0000000..c59cc81
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/sass_template.rb
@@ -0,0 +1,66 @@
+require 'tilt'
+
+module Sprockets
+ # This custom Tilt handler replaces the one built into Tilt. The
+ # main difference is that it uses a custom importer that plays nice
+ # with sprocket's caching system.
+ #
+ # See `SassImporter` for more infomation.
+ class SassTemplate < Tilt::Template
+ self.default_mime_type = 'text/css'
+
+ def self.engine_initialized?
+ defined?(::Sass::Engine) && defined?(::Sass::Script::Functions) &&
+ ::Sass::Script::Functions < Sprockets::SassFunctions
+ end
+
+ def initialize_engine
+ # Double check constant to avoid tilt warning
+ unless defined? ::Sass
+ require_template_library 'sass'
+ end
+
+ # Install custom functions. It'd be great if this didn't need to
+ # be installed globally, but could be passed into Engine as an
+ # option.
+ ::Sass::Script::Functions.send :include, Sprockets::SassFunctions
+ end
+
+ def prepare
+ end
+
+ def syntax
+ :sass
+ end
+
+ def evaluate(context, locals, &block)
+ # Use custom importer that knows about Sprockets Caching
+ cache_store = SassCacheStore.new(context.environment)
+
+ options = {
+ :filename => eval_file,
+ :line => line,
+ :syntax => syntax,
+ :cache_store => cache_store,
+ :importer => SassImporter.new(context.pathname.to_s),
+ :load_paths => context.environment.paths.map { |path| SassImporter.new(path.to_s) },
+ :sprockets => {
+ :context => context,
+ :environment => context.environment
+ }
+ }
+
+ result = ::Sass::Engine.new(data, options).render
+
+ # Track all imported files
+ filenames = ([options[:importer].imported_filenames] + options[:load_paths].map(&:imported_filenames)).flatten.uniq
+ filenames.each { |filename| context.depend_on(filename) }
+
+ result
+ rescue ::Sass::SyntaxError => e
+ # Annotates exception message with parse line number
+ context.__LINE__ = e.sass_backtrace.first[:line]
+ raise e
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/scss_template.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/scss_template.rb
new file mode 100644
index 0000000..511558c
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/scss_template.rb
@@ -0,0 +1,13 @@
+require 'sprockets/sass_template'
+
+module Sprockets
+ # Scss handler to replace Tilt's builtin one. See `SassTemplate` and
+ # `SassImporter` for more infomation.
+ class ScssTemplate < SassTemplate
+ self.default_mime_type = 'text/css'
+
+ def syntax
+ :scss
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/server.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/server.rb
new file mode 100644
index 0000000..e71f413
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/server.rb
@@ -0,0 +1,247 @@
+require 'time'
+require 'uri'
+
+module Sprockets
+ # `Server` is a concern mixed into `Environment` and
+ # `Index` that provides a Rack compatible `call`
+ # interface and url generation helpers.
+ module Server
+ # `call` implements the Rack 1.x specification which accepts an
+ # `env` Hash and returns a three item tuple with the status code,
+ # headers, and body.
+ #
+ # Mapping your environment at a url prefix will serve all assets
+ # in the path.
+ #
+ # map "/assets" do
+ # run Sprockets::Environment.new
+ # end
+ #
+ # A request for `"/assets/foo/bar.js"` will search your
+ # environment for `"foo/bar.js"`.
+ def call(env)
+ start_time = Time.now.to_f
+ time_elapsed = lambda { ((Time.now.to_f - start_time) * 1000).to_i }
+
+ msg = "Served asset #{env['PATH_INFO']} -"
+
+ # Mark session as "skipped" so no `Set-Cookie` header is set
+ env['rack.session.options'] ||= {}
+ env['rack.session.options'][:defer] = true
+ env['rack.session.options'][:skip] = true
+
+ # Extract the path from everything after the leading slash
+ path = unescape(env['PATH_INFO'].to_s.sub(/^\//, ''))
+
+ # Strip fingerprint
+ if fingerprint = path_fingerprint(path)
+ path = path.sub("-#{fingerprint}", '')
+ end
+
+ # URLs containing a `".."` are rejected for security reasons.
+ if forbidden_request?(path)
+ return forbidden_response
+ end
+
+ # Look up the asset.
+ asset = find_asset(path, :bundle => !body_only?(env))
+
+ # `find_asset` returns nil if the asset doesn't exist
+ if asset.nil?
+ logger.info "#{msg} 404 Not Found (#{time_elapsed.call}ms)"
+
+ # Return a 404 Not Found
+ not_found_response
+
+ # Check request headers `HTTP_IF_NONE_MATCH` against the asset digest
+ elsif etag_match?(asset, env)
+ logger.info "#{msg} 304 Not Modified (#{time_elapsed.call}ms)"
+
+ # Return a 304 Not Modified
+ not_modified_response(asset, env)
+
+ else
+ logger.info "#{msg} 200 OK (#{time_elapsed.call}ms)"
+
+ # Return a 200 with the asset contents
+ ok_response(asset, env)
+ end
+ rescue Exception => e
+ logger.error "Error compiling asset #{path}:"
+ logger.error "#{e.class.name}: #{e.message}"
+
+ case content_type_of(path)
+ when "application/javascript"
+ # Re-throw JavaScript asset exceptions to the browser
+ logger.info "#{msg} 500 Internal Server Error\n\n"
+ return javascript_exception_response(e)
+ when "text/css"
+ # Display CSS asset exceptions in the browser
+ logger.info "#{msg} 500 Internal Server Error\n\n"
+ return css_exception_response(e)
+ else
+ raise
+ end
+ end
+
+ private
+ def forbidden_request?(path)
+ # Prevent access to files elsewhere on the file system
+ #
+ # http://example.org/assets/../../../etc/passwd
+ #
+ path.include?("..") || Pathname.new(path).absolute?
+ end
+
+ # Returns a 403 Forbidden response tuple
+ def forbidden_response
+ [ 403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Forbidden" ] ]
+ end
+
+ # Returns a 404 Not Found response tuple
+ def not_found_response
+ [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9", "X-Cascade" => "pass" }, [ "Not found" ] ]
+ end
+
+ # Returns a JavaScript response that re-throws a Ruby exception
+ # in the browser
+ def javascript_exception_response(exception)
+ err = "#{exception.class.name}: #{exception.message}"
+ body = "throw Error(#{err.inspect})"
+ [ 200, { "Content-Type" => "application/javascript", "Content-Length" => Rack::Utils.bytesize(body).to_s }, [ body ] ]
+ end
+
+ # Returns a CSS response that hides all elements on the page and
+ # displays the exception
+ def css_exception_response(exception)
+ message = "\n#{exception.class.name}: #{exception.message}"
+ backtrace = "\n #{exception.backtrace.first}"
+
+ body = <<-CSS
+ html {
+ padding: 18px 36px;
+ }
+
+ head {
+ display: block;
+ }
+
+ body {
+ margin: 0;
+ padding: 0;
+ }
+
+ body > * {
+ display: none !important;
+ }
+
+ head:after, body:before, body:after {
+ display: block !important;
+ }
+
+ head:after {
+ font-family: sans-serif;
+ font-size: large;
+ font-weight: bold;
+ content: "Error compiling CSS asset";
+ }
+
+ body:before, body:after {
+ font-family: monospace;
+ white-space: pre-wrap;
+ }
+
+ body:before {
+ font-weight: bold;
+ content: "#{escape_css_content(message)}";
+ }
+
+ body:after {
+ content: "#{escape_css_content(backtrace)}";
+ }
+ CSS
+
+ [ 200, { "Content-Type" => "text/css;charset=utf-8", "Content-Length" => Rack::Utils.bytesize(body).to_s }, [ body ] ]
+ end
+
+ # Escape special characters for use inside a CSS content("...") string
+ def escape_css_content(content)
+ content.
+ gsub('\\', '\\\\005c ').
+ gsub("\n", '\\\\000a ').
+ gsub('"', '\\\\0022 ').
+ gsub('/', '\\\\002f ')
+ end
+
+ # Compare the requests `HTTP_IF_NONE_MATCH` against the assets digest
+ def etag_match?(asset, env)
+ env["HTTP_IF_NONE_MATCH"] == etag(asset)
+ end
+
+ # Test if `?body=1` or `body=true` query param is set
+ def body_only?(env)
+ env["QUERY_STRING"].to_s =~ /body=(1|t)/
+ end
+
+ # Returns a 304 Not Modified response tuple
+ def not_modified_response(asset, env)
+ [ 304, {}, [] ]
+ end
+
+ # Returns a 200 OK response tuple
+ def ok_response(asset, env)
+ [ 200, headers(env, asset, asset.length), asset ]
+ end
+
+ def headers(env, asset, length)
+ Hash.new.tap do |headers|
+ # Set content type and length headers
+ headers["Content-Type"] = asset.content_type
+ headers["Content-Length"] = length.to_s
+
+ # Set caching headers
+ headers["Cache-Control"] = "public"
+ headers["Last-Modified"] = asset.mtime.httpdate
+ headers["ETag"] = etag(asset)
+
+ # If the request url contains a fingerprint, set a long
+ # expires on the response
+ if path_fingerprint(env["PATH_INFO"])
+ headers["Cache-Control"] << ", max-age=31536000"
+
+ # Otherwise set `must-revalidate` since the asset could be modified.
+ else
+ headers["Cache-Control"] << ", must-revalidate"
+ end
+ end
+ end
+
+ # Gets digest fingerprint.
+ #
+ # "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+ # # => "0aa2105d29558f3eb790d411d7d8fb66"
+ #
+ def path_fingerprint(path)
+ path[/-([0-9a-f]{7,40})\.[^.]+\z/, 1]
+ end
+
+ # URI.unescape is deprecated on 1.9. We need to use URI::Parser
+ # if its available.
+ if defined? URI::DEFAULT_PARSER
+ def unescape(str)
+ str = URI::DEFAULT_PARSER.unescape(str)
+ str.force_encoding(Encoding.default_internal) if Encoding.default_internal
+ str
+ end
+ else
+ def unescape(str)
+ URI.unescape(str)
+ end
+ end
+
+ # Helper to quote the assets digest for use as an ETag.
+ def etag(asset)
+ %("#{asset.digest}")
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/static_asset.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/static_asset.rb
new file mode 100644
index 0000000..7ea0add
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/static_asset.rb
@@ -0,0 +1,60 @@
+require 'sprockets/asset'
+require 'fileutils'
+require 'zlib'
+
+module Sprockets
+ # `StaticAsset`s are used for files that are served verbatim without
+ # any processing or concatenation. These are typical images and
+ # other binary files.
+ class StaticAsset < Asset
+ # Returns file contents as its `source`.
+ def source
+ # File is read everytime to avoid memory bloat of large binary files
+ pathname.open('rb') { |f| f.read }
+ end
+
+ # Implemented for Rack SendFile support.
+ def to_path
+ pathname.to_s
+ end
+
+ # Save asset to disk.
+ def write_to(filename, options = {})
+ # Gzip contents if filename has '.gz'
+ unless options.key?(:compress)
+ options[:compress] = File.extname(filename) == '.gz' && File.extname(logical_path) != '.gz'
+ end
+
+ FileUtils.mkdir_p File.dirname(filename)
+
+ if options[:compress]
+ # Open file and run it through `Zlib`
+ pathname.open('rb') do |rd|
+ File.open("#{filename}+", 'wb') do |wr|
+ gz = Zlib::GzipWriter.new(wr, Zlib::BEST_COMPRESSION)
+ gz.mtime = mtime.to_i
+ buf = ""
+ while rd.read(16384, buf)
+ gz.write(buf)
+ end
+ gz.close
+ end
+ end
+ else
+ # If no compression needs to be done, we can just copy it into place.
+ FileUtils.cp(pathname, "#{filename}+")
+ end
+
+ # Atomic write
+ FileUtils.mv("#{filename}+", filename)
+
+ # Set mtime correctly
+ File.utime(mtime, mtime, filename)
+
+ nil
+ ensure
+ # Ensure tmp file gets cleaned up
+ FileUtils.rm("#{filename}+") if File.exist?("#{filename}+")
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/uglifier_compressor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/uglifier_compressor.rb
new file mode 100644
index 0000000..4d1e56c
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/uglifier_compressor.rb
@@ -0,0 +1,29 @@
+require 'tilt'
+
+module Sprockets
+ class UglifierCompressor < Tilt::Template
+ self.default_mime_type = 'application/javascript'
+
+ def self.engine_initialized?
+ defined?(::Uglifier)
+ end
+
+ def initialize_engine
+ require_template_library 'uglifier'
+ end
+
+ def prepare
+ end
+
+ def evaluate(context, locals, &block)
+ # Feature detect Uglifier 2.0 option support
+ if Uglifier::DEFAULTS[:copyright]
+ # Uglifier < 2.x
+ Uglifier.new(:copyright => false).compile(data)
+ else
+ # Uglifier >= 2.x
+ Uglifier.new(:comments => :none).compile(data)
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/utils.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/utils.rb
new file mode 100644
index 0000000..409aaf5
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/utils.rb
@@ -0,0 +1,69 @@
+module Sprockets
+ # `Utils`, we didn't know where else to put it!
+ module Utils
+ # If theres encoding support (aka Ruby 1.9)
+ if "".respond_to?(:valid_encoding?)
+ # Define UTF-8 BOM pattern matcher.
+ # Avoid using a Regexp literal because it inheirts the files
+ # encoding and we want to avoid syntax errors in other interpreters.
+ UTF8_BOM_PATTERN = Regexp.new("\\A\uFEFF".encode('utf-8'))
+
+ def self.read_unicode(pathname, external_encoding = Encoding.default_external)
+ pathname.open("r:#{external_encoding}") do |f|
+ f.read.tap do |data|
+ # Eager validate the file's encoding. In most cases we
+ # expect it to be UTF-8 unless `default_external` is set to
+ # something else. An error is usually raised if the file is
+ # saved as UTF-16 when we expected UTF-8.
+ if !data.valid_encoding?
+ raise EncodingError, "#{pathname} has a invalid " +
+ "#{data.encoding} byte sequence"
+
+ # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
+ elsif data.encoding.name == "UTF-8" && data =~ UTF8_BOM_PATTERN
+ data.sub!(UTF8_BOM_PATTERN, "")
+ end
+ end
+ end
+ end
+
+ else
+ # Define UTF-8 and UTF-16 BOM pattern matchers.
+ # Avoid using a Regexp literal to prevent syntax errors in other interpreters.
+ UTF8_BOM_PATTERN = Regexp.new("\\A\\xEF\\xBB\\xBF")
+ UTF16_BOM_PATTERN = Regexp.new("\\A(\\xFE\\xFF|\\xFF\\xFE)")
+
+ def self.read_unicode(pathname)
+ pathname.read.tap do |data|
+ # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
+ if data =~ UTF8_BOM_PATTERN
+ data.sub!(UTF8_BOM_PATTERN, "")
+
+ # If we find a UTF-16 BOM, theres nothing we can do on
+ # 1.8. Only UTF-8 is supported.
+ elsif data =~ UTF16_BOM_PATTERN
+ raise EncodingError, "#{pathname} has a UTF-16 BOM. " +
+ "Resave the file as UTF-8 or upgrade to Ruby 1.9."
+ end
+ end
+ end
+ end
+
+ # Prepends a leading "." to an extension if its missing.
+ #
+ # normalize_extension("js")
+ # # => ".js"
+ #
+ # normalize_extension(".css")
+ # # => ".css"
+ #
+ def self.normalize_extension(extension)
+ extension = extension.to_s
+ if extension[/^\./]
+ extension
+ else
+ ".#{extension}"
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/version.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/version.rb
new file mode 100644
index 0000000..5f30513
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/version.rb
@@ -0,0 +1,3 @@
+module Sprockets
+ VERSION = "2.12.4"
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/lib/sprockets/yui_compressor.rb b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/yui_compressor.rb
new file mode 100644
index 0000000..c0d6656
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/lib/sprockets/yui_compressor.rb
@@ -0,0 +1,27 @@
+require 'tilt'
+
+module Sprockets
+ class YUICompressor < Tilt::Template
+ def self.engine_initialized?
+ defined?(::YUI)
+ end
+
+ def initialize_engine
+ require_template_library 'yui/compressor'
+ end
+
+ def prepare
+ end
+
+ def evaluate(context, locals, &block)
+ case context.content_type
+ when 'application/javascript'
+ YUI::JavaScriptCompressor.new.compress(data)
+ when 'text/css'
+ YUI::CssCompressor.new.compress(data)
+ else
+ data
+ end
+ end
+ end
+end
diff --git a/debian/gems-compat/sprockets-2.12.4/metadata.yml b/debian/gems-compat/sprockets-2.12.4/metadata.yml
new file mode 100644
index 0000000..4c4c886
--- /dev/null
+++ b/debian/gems-compat/sprockets-2.12.4/metadata.yml
@@ -0,0 +1,320 @@
+--- !ruby/object:Gem::Specification
+name: sprockets
+version: !ruby/object:Gem::Version
+ version: 2.12.4
+platform: ruby
+authors:
+- Sam Stephenson
+- Joshua Peek
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+ name: hike
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.2'
+ type: :runtime
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.2'
+- !ruby/object:Gem::Dependency
+ name: multi_json
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+ type: :runtime
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+- !ruby/object:Gem::Dependency
+ name: rack
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+ type: :runtime
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+- !ruby/object:Gem::Dependency
+ name: tilt
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.1'
+ - - "!="
+ - !ruby/object:Gem::Version
+ version: 1.3.0
+ type: :runtime
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.1'
+ - - "!="
+ - !ruby/object:Gem::Version
+ version: 1.3.0
+- !ruby/object:Gem::Dependency
+ name: closure-compiler
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+- !ruby/object:Gem::Dependency
+ name: coffee-script
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '2.0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '2.0'
+- !ruby/object:Gem::Dependency
+ name: coffee-script-source
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.2'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.2'
+- !ruby/object:Gem::Dependency
+ name: eco
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+- !ruby/object:Gem::Dependency
+ name: ejs
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+- !ruby/object:Gem::Dependency
+ name: execjs
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '1.0'
+- !ruby/object:Gem::Dependency
+ name: json
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+- !ruby/object:Gem::Dependency
+ name: rack-test
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+- !ruby/object:Gem::Dependency
+ name: rake
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+- !ruby/object:Gem::Dependency
+ name: sass
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '3.1'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - "~>"
+ - !ruby/object:Gem::Version
+ version: '3.1'
+- !ruby/object:Gem::Dependency
+ name: uglifier
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+- !ruby/object:Gem::Dependency
+ name: yui-compressor
+ requirement: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+ type: :development
+ prerelease: false
+ version_requirements: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+description: Sprockets is a Rack-based asset packaging system that concatenates and
+ serves JavaScript, CoffeeScript, CSS, LESS, Sass, and SCSS.
+email:
+- sstephenson at gmail.com
+- josh at joshpeek.com
+executables:
+- sprockets
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/sprockets
+- lib/rake/sprocketstask.rb
+- lib/sprockets.rb
+- lib/sprockets/asset.rb
+- lib/sprockets/asset_attributes.rb
+- lib/sprockets/base.rb
+- lib/sprockets/bundled_asset.rb
+- lib/sprockets/cache/file_store.rb
+- lib/sprockets/caching.rb
+- lib/sprockets/charset_normalizer.rb
+- lib/sprockets/closure_compressor.rb
+- lib/sprockets/compressing.rb
+- lib/sprockets/context.rb
+- lib/sprockets/directive_processor.rb
+- lib/sprockets/eco_template.rb
+- lib/sprockets/ejs_template.rb
+- lib/sprockets/engines.rb
+- lib/sprockets/environment.rb
+- lib/sprockets/errors.rb
+- lib/sprockets/index.rb
+- lib/sprockets/jst_processor.rb
+- lib/sprockets/manifest.rb
+- lib/sprockets/mime.rb
+- lib/sprockets/paths.rb
+- lib/sprockets/processed_asset.rb
+- lib/sprockets/processing.rb
+- lib/sprockets/processor.rb
+- lib/sprockets/safety_colons.rb
+- lib/sprockets/sass_cache_store.rb
+- lib/sprockets/sass_compressor.rb
+- lib/sprockets/sass_functions.rb
+- lib/sprockets/sass_importer.rb
+- lib/sprockets/sass_template.rb
+- lib/sprockets/scss_template.rb
+- lib/sprockets/server.rb
+- lib/sprockets/static_asset.rb
+- lib/sprockets/uglifier_compressor.rb
+- lib/sprockets/utils.rb
+- lib/sprockets/version.rb
+- lib/sprockets/yui_compressor.rb
+homepage: http://getsprockets.org/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+ requirements:
+ - - ">="
+ - !ruby/object:Gem::Version
+ version: '0'
+requirements: []
+rubyforge_project: sprockets
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Rack-based asset packaging system
+test_files: []
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-ruby-extras/diaspora.git
More information about the Pkg-ruby-extras-commits
mailing list