sprockets 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec93323cfb4ee9daedbf87dd84da7e788eb5fed5
-  data.tar.gz: 5e43ec7e11e4d9fd167ed70f00633ae0995a72aa
+  metadata.gz: 12abb21d7b7beb859bc402887f2b6a1081408103
+  data.tar.gz: f90c9972dc5ee2d6db3ca2d052bd20440eadce4f
 SHA512:
-  metadata.gz: b891fd59f01709b0ded0462aec839bfb346c36e379a48e3eaf770e60d369e87040e6ec0941b35fe2a79411a2e39cbf48b2131d2ef241d62dadd84640d8df3276
-  data.tar.gz: dc144eaac6981bdbea7838822e049fb026304d615b94286ec989f3d3ada6731f978e5151eb67caa91f81a03fbf66037027f3c90ceaa68d9aa57897ae35390977
+  metadata.gz: 7d47b7a7900ace1158e5d37f4414359c83266e7e37f4fbad746f657139719b57b36dfd260c66ed03768623d52cb0bcc859a39fde55f38d9c80e685d1e50ae437
+  data.tar.gz: 4ea4085268e814ad668d8d6038f9f0253c7afbbdd97c79c596eb7e82939ae7720d8f1c9674432d301759e225a8d5c1677c82c45d028ae86ddc639ebd6cbdffca

data/CHANGELOG.md

@@ -0,0 +1,222 @@
+**3.3.0** (August 12, 2015)
+
+* Change internal cache lookup to use relative asset paths instead of absolute paths.
+
+**3.2.0** (June 2, 2015)
+
+* Updated SRI integrity to align with spec changes
+* Deprecated Manifest integrity attribute
+* Cleanup concatenating JS sources with newlines
+
+**3.1.0** (May 10, 2015)
+
+* Removed "index" logical path normalization. Asset#logical_path is always the
+  full logical path to the index file.
+* Fixed static asset mtimes
+* Fix manifest cleanup by age
+* Removed redundant minifier level cache
+* Updated SRI format according to spec changes
+
+**3.0.3** (April 27, 2015)
+
+* Fix static asset mtime fallback
+* Only warn when specified asset version can not be loaded.
+
+**3.0.2** (April 22, 2015)
+
+* Ensure legacy Tilt handlers return String class data. Fixes issues with Haml
+  Tilt handler.
+* Type check and improve error messages raised on bad processor returned results.
+* Improve error message for relative paths not under load path.
+* Changed HTML encoding fallback from ISO-8859-1 to default external.
+* Avoid falling back to 0 mtimes which may cause warnings with tar
+
+**3.0.1** (April 14, 2015)
+
+* Fixed `Context#depend_on` with paths outside the load path
+
+**3.0.0** (April 12, 2015)
+
+[Guide to upgrading from Sprockets 2.x to 3.x](https://github.com/rails/sprockets/blob/master/UPGRADING.md)
+
+* New processor API. Tilt interface is deprecated.
+* Improved file store caching backend.
+* MIME Types now accept charset custom charset detecters. Improves support for UTF-16/32 files.
+* Environment#version no longer affects asset digests. Only used for busting the asset cache.
+* Removed builtin support for LESS.
+* Removed `//= include` directive support.
+* Deprecated `BundledAsset#to_a`. Use `BundledAsset#included` to access debugging subcomponents.
+* Support circular dependencies. For parity with ES6 modules.
+* Manifest compilation will no longer generate .gz files by default. [Mixing
+  Content-Encoding and ETags is just a bad
+  idea](https://issues.apache.org/bugzilla/show_bug.cgi?id=39727)
+* Added linked or referenced assets. When an asset is compiled, any of its links will be compiled as well.
+* Introduce some limitations around enumerating all logical paths. 4.x will deprecate it and favor linked manifests for compliation.
+* Add Asset integrity attribute for Subresource Integrity
+* Default digest changed to SHA256. Configuring `digest_class` is deprecated.
+* Rename `Asset#digest` to `Asset#hexdigest`. `Asset#digest` is deprecated and will
+  return a raw byte String in 4.x.
+* Added transitional compatibility flag to `Environment#resolve(path, compat: true)`. 2.x mode operates with `compat: true` and 4.x with `compat: false`
+* `manifest-abc123.json` renamed to `.sprockets-abc123.json`
+
+**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)
+
+* Cache store must now be an LRU implementation.
+* Default digest changed to SHA1. To continue using MD5.
+  `env.digest_class = Digest::MD5`.
+
+**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 separated 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 sufficient.
+
+**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.

data/lib/sprockets/base.rb

@@ -10,6 +10,7 @@ require 'sprockets/path_dependency_utils'
 require 'sprockets/path_utils'
 require 'sprockets/resolve'
 require 'sprockets/server'
+require 'sprockets/loader'
 
 module Sprockets
   # `Base` class for `Environment` and `Cached`.
@@ -48,9 +49,10 @@ module Sprockets
         # Caveat: Digests are cached by the path's current mtime. Its possible
         # for a files contents to have changed and its mtime to have been
         # negligently reset thus appearing as if the file hasn't changed on
-        # disk. Also, the mtime is only read to the nearest second. Its
+        # disk. Also, the mtime is only read to the nearest second. It's
         # also possible the file was updated more than once in a given second.
-        cache.fetch("file_digest:#{path}:#{stat.mtime.to_i}") do
+        key = UnloadedAsset.new(path, self).file_digest_key(stat.mtime.to_i)
+        cache.fetch(key) do
           self.stat_digest(path, stat)
         end
       end

data/lib/sprockets/dependencies.rb

@@ -51,18 +51,18 @@ module Sprockets
     end
     alias_method :depend_on, :add_dependency
 
-    # Internal: Resolve set of dependency URIs.
-    #
-    # Returns Array of resolved Objects.
-    def resolve_dependencies(uris)
-      uris.map { |uri| resolve_dependency(uri) }
-    end
-
     # Internal: Resolve dependency URIs.
     #
     # Returns resolved Object.
     def resolve_dependency(str)
-      scheme = str[/([^:]+)/, 1]
+      # Optimize for the most common scheme to
+      # save 22k allocations on an average Spree app.
+      scheme = if str.start_with?('file-digest:'.freeze)
+        'file-digest'.freeze
+      else
+        str[/([^:]+)/, 1]
+      end
+
       if resolver = config[:dependency_resolvers][scheme]
         resolver.call(self, str)
       else

data/lib/sprockets/digest_utils.rb

@@ -66,7 +66,7 @@ module Sprockets
         elsif klass == FalseClass
           digest << 'FalseClass'
         elsif klass == NilClass
-          digest << 'NilClass'
+          digest << 'NilClass'.freeze
         elsif klass == Array
           digest << 'Array'
           queue.concat(obj)

data/lib/sprockets/loader.rb

@@ -12,37 +12,198 @@ require 'sprockets/transformers'
 require 'sprockets/uri_utils'
 
 module Sprockets
+
+  # Internal: Used to parse and store the URI to an unloaded asset
+  # Generates keys used to store and retrieve items from cache
+  class UnloadedAsset
+
+    # Internal: Initialize object for generating cache keys
+    #
+    # uri - A String containing complete URI to a file including schema
+    #       and full path such as
+    #       "file:///Path/app/assets/js/app.js?type=application/javascript"
+    # env - The current "environment" that assets are being loaded into.
+    #       We need it so we know where the +root+ (directory where sprockets
+    #       is being invoked). We also need for the `file_digest` method,
+    #       since, for some strange reason, memoization is provided by
+    #       overriding methods such as `stat` in the `PathUtils` module.
+    #
+    # Returns UnloadedAsset.
+    def initialize(uri, env)
+      @uri             = uri
+      @env             = env
+      @root            = env.root
+      @relative_path   = get_relative_path_from_uri
+      @params          = nil # lazy loaded
+      @filename        = nil # lazy loaded
+    end
+    attr_reader :relative_path, :root, :uri
+
+
+    # Internal: Full file path without schema
+    #
+    # This returns a string containing the full path to the asset without the schema.
+    # Information is loaded lazilly since we want `UnloadedAsset.new(dep, self).relative_path`
+    # to be fast. Calling this method the first time allocates an array and a hash.
+    #
+    # Example
+    #
+    # If the URI is `file:///Full/path/app/assets/javascripts/application.js"` then the
+    # filename would be `"/Full/path/app/assets/javascripts/application.js"`
+    #
+    # Returns a String.
+    def filename
+      unless @filename
+        load_file_params
+      end
+      @filename
+    end
+
+    # Internal: Hash of param values
+    #
+    # This information is generated and used internally by sprockets.
+    # Known keys include `:type` which store the asset's mime-type, `:id` which is a fully resolved
+    # digest for the asset (includes dependency digest as opposed to a digest of only file contents)
+    # and `:pipeline`. Hash may be empty.
+    #
+    # Example
+    #
+    # If the URI is `file:///Full/path/app/assets/javascripts/application.js"type=application/javascript`
+    # Then the params would be `{type: "application/javascript"}`
+    #
+    # Returns a Hash.
+    def params
+      unless @params
+        load_file_params
+      end
+      @params
+    end
+
+    # Internal: Key of asset
+    #
+    # Used to retrieve an asset from the cache based on relative path to asset
+    #
+    # Returns a String.
+    def asset_key
+      "asset-uri:#{relative_path}"
+    end
+
+    # Public: Dependency History key
+    #
+    # Used to retrieve an array of "histories" each of which contain a set of stored dependencies
+    # for a given asset path and filename digest.
+    #
+    # A dependency can refer to either an asset i.e. index.js
+    # may rely on jquery.js (so jquery.js is a dependency), or other factors that may affect
+    # compilation, such as the VERSION of sprockets (i.e. the environment) and what "processors"
+    # are used.
+    #
+    # For example a history array with one Set of dependencies may look like:
+    #
+    # [["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+    #   "file-digest:///Full/path/app/assets/stylesheets/application.css",
+    #   "processors:type=text/css&file_type=text/css&pipeline=self",
+    #   "file-digest:///Full/path/app/assets/stylesheets"]]
+    #
+    # This method of asset lookup is used to ensure that none of the dependencies have been modified
+    # since last lookup. If one of them has, the key will be different and a new entry must be stored.
+    #
+    # URI depndencies are later converted to relative paths
+    #
+    # Returns a String.
+    def dependency_history_key
+      "asset-uri-cache-dependencies:#{relative_path}:#{ @env.file_digest(filename) }"
+    end
+
+    # Internal: Digest key
+    #
+    # Used to retrieve a string containing the relative path to an asset based on
+    # a digest. The digest is generated from dependencies stored via information stored in
+    # the `dependency_history_key` after each of the "dependencies" is "resolved" for example
+    # "environment-version" may be resolved to "environment-1.0-3.2.0" for version "3.2.0" of sprockets
+    #
+    # Returns a String.
+    def digest_key(digest)
+      "asset-uri-digest:#{relative_path}:#{digest}"
+    end
+
+    # Internal: File digest key
+    #
+    # The digest for a given file won't change if the path and the stat time hasn't changed
+    # We can save time by not re-computing this information and storing it in the cache
+    #
+    # Returns a String.
+    def file_digest_key(stat)
+      "file_digest:#{relative_path}:#{stat}"
+    end
+
+    private
+      # Internal: Parses uri into filename and params hash
+      #
+      # Returns Array with filename and params hash
+      def load_file_params
+        @filename, @params = URIUtils.parse_asset_uri(uri)
+      end
+
+      # Internal: Converts uri to a relative path
+      #
+      # Returns a relative path if given URI is in the `@env.root` of where sprockets
+      # is running. Otherwise it returns a string of the absolute path
+      #
+      # Returns a String.
+      def get_relative_path_from_uri
+        path = uri.sub(/\Afile:\/\//, "".freeze)
+        if relative_path = PathUtils.split_subpath(root, path)
+          relative_path
+        else
+          path
+        end
+      end
+  end
   # The loader phase takes a asset URI location and returns a constructed Asset
   # object.
   module Loader
     include DigestUtils, PathUtils, ProcessorUtils, URIUtils
     include Engines, Mime, Processing, Resolve, Transformers
 
-    # Public: Load Asset by AssetURI.
+
+    # Public: Load Asset by Asset URI.
+    #
+    # uri - A String containing complete URI to a file including schema
+    #       and full path such as:
+    #       "file:///Path/app/assets/js/app.js?type=application/javascript"
     #
-    # uri - AssetURI
     #
     # Returns Asset.
     def load(uri)
-      filename, params = parse_asset_uri(uri)
-      if params.key?(:id)
-        unless asset = cache.get("asset-uri:#{VERSION}:#{uri}", true)
-          id = params.delete(:id)
-          uri_without_id = build_asset_uri(filename, params)
-          asset = load_asset_by_uri(uri_without_id, filename, params)
+      unloaded = UnloadedAsset.new(uri, self)
+      if unloaded.params.key?(:id)
+        unless asset = cache.get(unloaded.asset_key, true)
+          id = unloaded.params.delete(:id)
+          uri_without_id = build_asset_uri(unloaded.filename, unloaded.params)
+          asset = load_from_unloaded(UnloadedAsset.new(uri_without_id, self))
           if asset[:id] != id
             @logger.warn "Sprockets load error: Tried to find #{uri}, but latest was id #{asset[:id]}"
           end
         end
       else
-        asset = fetch_asset_from_dependency_cache(uri, filename) do |paths|
+        asset = fetch_asset_from_dependency_cache(unloaded) do |paths|
+          # When asset is previously generated, its "dependencies" are stored in the cache.
+          # The presence of `paths` indicates dependencies were stored.
+          # We can check to see if the dependencies have not changed by "resolving" them and
+          # generating a digest key from the resolved entries. If this digest key has not
+          # changed the asset will be pulled from cache.
+          #
+          # If this `paths` is present but the cache returns nothing then `fetch_asset_from_dependency_cache`
+          # will confusingly be called again with `paths` set to nil where the asset will be
+          # loaded from disk.
           if paths
-            digest = digest(resolve_dependencies(paths))
-            if id_uri = cache.get("asset-uri-digest:#{VERSION}:#{uri}:#{digest}", true)
-              cache.get("asset-uri:#{VERSION}:#{id_uri}", true)
+            digest = DigestUtils.digest(resolve_dependencies(paths))
+            if uri_from_cache = cache.get(unloaded.digest_key(digest), true)
+              cache.get(UnloadedAsset.new(uri_from_cache, self).asset_key, true)
             end
           else
-            load_asset_by_uri(uri, filename, params)
+            load_from_unloaded(unloaded)
           end
         end
       end
@@ -50,25 +211,32 @@ module Sprockets
     end
 
     private
-      def load_asset_by_uri(uri, filename, params)
-        unless file?(filename)
-          raise FileNotFound, "could not find file: #{filename}"
+
+      # Internal: Loads an asset and saves it to cache
+      #
+      # unloaded - An UnloadedAsset
+      #
+      # This method is only called when the given unloaded asset could not be
+      # successfully pulled from cache.
+      def load_from_unloaded(unloaded)
+        unless file?(unloaded.filename)
+          raise FileNotFound, "could not find file: #{unloaded.filename}"
         end
 
-        load_path, logical_path = paths_split(config[:paths], filename)
+        load_path, logical_path = paths_split(config[:paths], unloaded.filename)
 
         unless load_path
-          raise FileOutsidePaths, "#{filename} is no longer under a load path: #{self.paths.join(', ')}"
+          raise FileOutsidePaths, "#{unloaded.filename} is no longer under a load path: #{self.paths.join(', ')}"
         end
 
         logical_path, file_type, engine_extnames, _ = parse_path_extnames(logical_path)
         name = logical_path
 
-        if pipeline = params[:pipeline]
+        if pipeline = unloaded.params[:pipeline]
           logical_path += ".#{pipeline}"
         end
 
-        if type = params[:type]
+        if type = unloaded.params[:type]
           logical_path += config[:mime_types][type][:extensions].first
         end
 
@@ -86,8 +254,8 @@ module Sprockets
           result = call_processors(processors, {
             environment: self,
             cache: self.cache,
-            uri: uri,
-            filename: filename,
+            uri: unloaded.uri,
+            filename: unloaded.filename,
             load_path: load_path,
             name: name,
             content_type: type,
@@ -101,28 +269,28 @@ module Sprockets
             length: source.bytesize
           )
         else
-          dependencies << build_file_digest_uri(filename)
+          dependencies << build_file_digest_uri(unloaded.filename)
           metadata = {
-            digest: file_digest(filename),
-            length: self.stat(filename).size,
+            digest: file_digest(unloaded.filename),
+            length: self.stat(unloaded.filename).size,
             dependencies: dependencies
           }
         end
 
         asset = {
-          uri: uri,
+          uri: unloaded.uri,
           load_path: load_path,
-          filename: filename,
+          filename: unloaded.filename,
           name: name,
           logical_path: logical_path,
           content_type: type,
           source: source,
           metadata: metadata,
-          dependencies_digest: digest(resolve_dependencies(metadata[:dependencies]))
+          dependencies_digest: DigestUtils.digest(resolve_dependencies(metadata[:dependencies]))
         }
 
         asset[:id]  = pack_hexdigest(digest(asset))
-        asset[:uri] = build_asset_uri(filename, params.merge(id: asset[:id]))
+        asset[:uri] = build_asset_uri(unloaded.filename, unloaded.params.merge(id: asset[:id]))
 
         # Deprecated: Avoid tracking Asset mtime
         asset[:mtime] = metadata[:dependencies].map { |u|
@@ -133,18 +301,92 @@ module Sprockets
             nil
           end
         }.compact.max
-        asset[:mtime] ||= self.stat(filename).mtime.to_i
+        asset[:mtime] ||= self.stat(unloaded.filename).mtime.to_i
 
-        cache.set("asset-uri:#{VERSION}:#{asset[:uri]}", asset, true)
-        cache.set("asset-uri-digest:#{VERSION}:#{uri}:#{asset[:dependencies_digest]}", asset[:uri], true)
+        # Unloaded asset and stored_asset now have a different URI
+        stored_asset = UnloadedAsset.new(asset[:uri], self)
+
+        # Save the asset in the cache under the new URI
+        cache.set(stored_asset.asset_key, asset, true)
+
+        # Save the new relative path for the digest key of the unloaded asset
+        cache.set(unloaded.digest_key(asset[:dependencies_digest]), stored_asset.relative_path, true) # wat
 
         asset
       end
 
-      def fetch_asset_from_dependency_cache(uri, filename, limit = 3)
-        key = "asset-uri-cache-dependencies:#{VERSION}:#{uri}:#{file_digest(filename)}"
-        history = cache.get(key) || []
 
+      # Internal: Resolve set of dependency URIs.
+      #
+      # uris - An Array of "dependencies" for example:
+      #        ["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+      #           "file-digest:///Full/path/app/assets/stylesheets/application.css",
+      #           "processors:type=text/css&file_type=text/css&pipeline=self",
+      #           "file-digest:///Full/path/app/assets/stylesheets"]
+      #
+      # Returns back array of things that the given uri dpends on
+      # For example the environment version, if you're using a different version of sprockets
+      # then the dependencies should be different, this is used only for generating cache key
+      # for example the "environment-version" may be resolved to "environment-1.0-3.2.0" for
+      #  version "3.2.0" of sprockets.
+      #
+      # Any paths that are returned are converted to relative paths
+      #
+      # Returns array of resolved dependencies
+      def resolve_dependencies(uris)
+        uris.map do |uri|
+          dependency = resolve_dependency(uri)
+          case dependency
+          when Array
+            dependency.map do |dep|
+              if dep && dep.is_a?(String)
+                UnloadedAsset.new(dep, self).relative_path
+              else
+                dep
+              end
+            end
+          else
+            dependency
+          end
+        end
+      end
+
+      # Internal: Retrieves an asset based on its digest
+      #
+      # unloaded - An UnloadedAsset
+      # limit    - A Fixnum which sets the maximum number of versions of "histories"
+      #            stored in the cache
+      #
+      # This method attempts to retrieve the last `limit` number of histories of an asset
+      # from the cache a "history" which is an array of unresolved "dependencies" that the asset needs
+      # to compile. In this case A dependency can refer to either an asset i.e. index.js
+      # may rely on jquery.js (so jquery.js is a depndency), or other factors that may affect
+      # compilation, such as the VERSION of sprockets (i.e. the environment) and what "processors"
+      # are used.
+      #
+      # For example a history array may look something like this
+      #
+      #   [["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+      #     "file-digest:///Full/path/app/assets/stylesheets/application.css",
+      #     "processors:type=text/css&file_type=text/css&pipeline=self",
+      #     "file-digest:///Full/path/app/assets/stylesheets"]]
+      #
+      # Where the first entry is a Set of dependencies for last generated version of that asset.
+      # Multiple versions are stored since sprockets keeps the last `limit` number of assets
+      # generated present in the system.
+      #
+      # If a "history" of dependencies is present in the cache, each version of "history" will be
+      # yielded to the passed block which is responsible for loading the asset. If found, the existing
+      # history will be saved with the dependency that found a valid asset moved to the front.
+      #
+      # If no history is present, or if none of the histories could be resolved to a valid asset then,
+      # the block is yielded to and expected to return a valid asset.
+      # When this happens the dependencies for the returned asset are added to the "history", and older
+      # entries are removed if the "history" is above `limit`.
+      def fetch_asset_from_dependency_cache(unloaded, limit = 3)
+        key = unloaded.dependency_history_key
+
+        history = cache.get(key) || []
         history.each_with_index do |deps, index|
           if asset = yield(deps)
             cache.set(key, history.rotate!(index)) if index > 0

data/lib/sprockets/uri_utils.rb

@@ -48,7 +48,7 @@ module Sprockets
       path.force_encoding(Encoding::UTF_8)
 
       # Hack for parsing Windows "file:///C:/Users/IEUser" paths
-      path.gsub!(/^\/([a-zA-Z]:)/, '\1')
+      path.gsub!(/^\/([a-zA-Z]:)/, '\1'.freeze)
 
       [scheme, host, path, query]
     end
@@ -125,7 +125,7 @@ module Sprockets
     def parse_file_digest_uri(uri)
       scheme, _, path, _ = split_file_uri(uri)
 
-      unless scheme == 'file-digest'
+      unless scheme == 'file-digest'.freeze
         raise URI::InvalidURIError, "expected file-digest scheme: #{uri}"
       end
 
@@ -143,7 +143,7 @@ module Sprockets
     #
     # Returns String URI.
     def build_file_digest_uri(path)
-      join_file_uri("file-digest", nil, path, nil)
+      join_file_uri('file-digest'.freeze, nil, path, nil)
     end
 
     # Internal: Serialize hash of params into query string.

data/lib/sprockets/version.rb

@@ -1,3 +1,3 @@
 module Sprockets
-  VERSION = "3.2.0"
+  VERSION = "3.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sprockets
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Sam Stephenson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-02 00:00:00.000000000 Z
+date: 2015-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -217,6 +217,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - bin/sprockets
@@ -313,3 +314,4 @@ signing_key:
 specification_version: 4
 summary: Rack-based asset packaging system
 test_files: []
+has_rdoc: