sprockets 3.7.3 → 4.2.2

data/lib/sprockets/bundle.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
 require 'set'
 require 'sprockets/utils'
+require 'sprockets/uri_utils'
 
 module Sprockets
   # Internal: Bundle processor takes a single file asset and prepends all the
@@ -8,22 +10,39 @@ module Sprockets
   # Uses pipeline metadata:
   #
   #   :required - Ordered Set of asset URIs to prepend
-  #   :stubbed  - Set of asset URIs to substract from the required set.
+  #   :stubbed  - Set of asset URIs to subtract from the required set.
   #
   # Also see DirectiveProcessor.
   class Bundle
     def self.call(input)
       env  = input[:environment]
       type = input[:content_type]
+      input[:links] ||= Set.new
       dependencies = Set.new(input[:metadata][:dependencies])
 
-      processed_uri, deps = env.resolve(input[:filename], accept: type, pipeline: :self, compat: false)
+      processed_uri, deps = env.resolve(input[:filename], accept: type, pipeline: :self)
       dependencies.merge(deps)
 
+      # DirectiveProcessor (and any other transformers called here with pipeline=self)
+      primary_asset = env.load(processed_uri)
+      to_load = primary_asset.metadata.delete(:to_load) || Set.new
+      to_link = primary_asset.metadata.delete(:to_link) || Set.new
+
+      to_load.each do |uri|
+        loaded_asset = env.load(uri)
+        dependencies.merge(loaded_asset.metadata[:dependencies])
+        if to_link.include?(uri)
+          primary_metadata = primary_asset.metadata
+          input[:links]            << loaded_asset.uri
+          primary_metadata[:links] << loaded_asset.uri
+        end
+      end
+
       find_required = proc { |uri| env.load(uri).metadata[:required] }
       required = Utils.dfs(processed_uri, &find_required)
       stubbed  = Utils.dfs(env.load(processed_uri).metadata[:stubbed], &find_required)
       required.subtract(stubbed)
+      dedup(required)
       assets = required.map { |uri| env.load(uri) }
 
       (required + stubbed).each do |uri|
@@ -31,21 +50,38 @@ module Sprockets
       end
 
       reducers = Hash[env.match_mime_type_keys(env.config[:bundle_reducers], type).flat_map(&:to_a)]
-      process_bundle_reducers(assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+      process_bundle_reducers(input, assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+    end
+
+    # Internal: Removes uri from required if it's already included as an alias.
+    #
+    # required - Set of required uris
+    #
+    # Returns deduped set of uris
+    def self.dedup(required)
+      dupes = required.reduce([]) do |r, uri|
+        path, params = URIUtils.parse_asset_uri(uri)
+        if (params.delete(:index_alias))
+          r << URIUtils.build_asset_uri(path, params)
+        end
+        r
+      end
+      required.subtract(dupes)
     end
 
     # Internal: Run bundle reducers on set of Assets producing a reduced
     # metadata Hash.
     #
+    # filename - String bundle filename
     # assets - Array of Assets
     # reducers - Array of [initial, reducer_proc] pairs
     #
     # Returns reduced asset metadata Hash.
-    def self.process_bundle_reducers(assets, reducers)
+    def self.process_bundle_reducers(input, assets, reducers)
       initial = {}
       reducers.each do |k, (v, _)|
         if v.respond_to?(:call)
-          initial[k] = v.call
+          initial[k] = v.call(input)
         elsif !v.nil?
           initial[k] = v
         end

data/lib/sprockets/cache/file_store.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'fileutils'
 require 'logger'
 require 'sprockets/encoding_utils'
@@ -19,7 +20,9 @@ module Sprockets
     class FileStore
       # Internal: Default key limit for store.
       DEFAULT_MAX_SIZE = 25 * 1024 * 1024
-
+      EXCLUDED_DIRS = ['.', '..'].freeze
+      GITKEEP_FILES = ['.gitkeep', '.keep'].freeze
+      
       # Internal: Default standard error fatal logger.
       #
       # Returns a Logger.
@@ -32,8 +35,10 @@ module Sprockets
       # Public: Initialize the cache store.
       #
       # root     - A String path to a directory to persist cached values to.
-      # max_size - A Integer of the maximum number of keys the store will hold.
-      #            (default: 1000).
+      # max_size - A Integer of the maximum size the store will hold (in bytes).
+      #            (default: 25MB).
+      # logger   - The logger to which some info will be printed.
+      #            (default logger level is FATAL and won't output anything).
       def initialize(root, max_size = DEFAULT_MAX_SIZE, logger = self.class.default_logger)
         @root     = root
         @max_size = max_size
@@ -122,6 +127,23 @@ module Sprockets
         "#<#{self.class} size=#{size}/#{@max_size}>"
       end
 
+      # Public: Clear the cache
+      #
+      # adapted from ActiveSupport::Cache::FileStore#clear
+      #
+      # Deletes all items from the cache. In this case it deletes all the entries in the specified
+      # file store directory except for .keep or .gitkeep. Be careful which directory is specified
+      # as @root because everything in that directory will be deleted.
+      #
+      # Returns true
+      def clear(options=nil)
+        if File.exist?(@root)
+          root_dirs = Dir.entries(@root).reject { |f| (EXCLUDED_DIRS + GITKEEP_FILES).include?(f) }
+          FileUtils.rm_r(root_dirs.collect{ |f| File.join(@root, f) })
+        end
+        true
+      end
+
       private
         # Internal: Get all cache files along with stats.
         #

data/lib/sprockets/cache/memory_store.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sprockets
   class Cache
     # Public: Basic in memory LRU cache.
@@ -21,6 +22,7 @@ module Sprockets
       def initialize(max_size = DEFAULT_MAX_SIZE)
         @max_size = max_size
         @cache = {}
+        @mutex = Mutex.new
       end
 
       # Public: Retrieve value from cache.
@@ -31,12 +33,14 @@ module Sprockets
       #
       # Returns Object or nil or the value is not set.
       def get(key)
-        exists = true
-        value = @cache.delete(key) { exists = false }
-        if exists
-          @cache[key] = value
-        else
-          nil
+        @mutex.synchronize do
+          exists = true
+          value = @cache.delete(key) { exists = false }
+          if exists
+            @cache[key] = value
+          else
+            nil
+          end
         end
       end
 
@@ -49,9 +53,11 @@ module Sprockets
       #
       # Returns Object value.
       def set(key, value)
-        @cache.delete(key)
-        @cache[key] = value
-        @cache.shift if @cache.size > @max_size
+        @mutex.synchronize do
+          @cache.delete(key)
+          @cache[key] = value
+          @cache.shift if @cache.size > @max_size
+        end
         value
       end
 
@@ -59,7 +65,19 @@ module Sprockets
       #
       # Returns String.
       def inspect
-        "#<#{self.class} size=#{@cache.size}/#{@max_size}>"
+        @mutex.synchronize do
+          "#<#{self.class} size=#{@cache.size}/#{@max_size}>"
+        end
+      end
+
+      # Public: Clear the cache
+      #
+      # Returns true
+      def clear(options=nil)
+        @mutex.synchronize do
+          @cache.clear
+        end
+        true
       end
     end
   end

data/lib/sprockets/cache/null_store.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sprockets
   class Cache
     # Public: A compatible cache store that doesn't store anything. Used by
@@ -41,6 +42,13 @@ module Sprockets
       def inspect
         "#<#{self.class}>"
       end
+
+      # Public: Simulate clearing the cache
+      #
+      # Returns true
+      def clear(options=nil)
+        true
+      end
     end
   end
 end

data/lib/sprockets/cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'logger'
 require 'sprockets/digest_utils'
 
@@ -35,6 +36,12 @@ module Sprockets
   #
   #   Returns argument value.
   #
+  # clear(options)
+  #
+  #   Clear the entire cache. Be careful with this method since it could
+  #   affect other processes if shared cache is being used.
+  #
+  #   The options hash is passed to the underlying cache implementation.
   class Cache
     # Builtin cache stores.
     autoload :FileStore,   'sprockets/cache/file_store'
@@ -44,7 +51,7 @@ module Sprockets
     # Internal: Cache key version for this class. Rarely should have to change
     # unless the cache format radically changes. Will be bump on major version
     # releases though.
-    VERSION = '3.0'
+    VERSION = '4.0.0'
 
     def self.default_logger
       logger = Logger.new($stderr)
@@ -55,7 +62,7 @@ module Sprockets
     # Internal: Wrap a backend cache store.
     #
     # Always assign a backend cache store instance to Environment#cache= and
-    # use Environment#cache to retreive a wrapped interface.
+    # use Environment#cache to retrieve a wrapped interface.
     #
     # cache - A compatible backend cache store instance.
     def initialize(cache = nil, logger = self.class.default_logger)
@@ -143,6 +150,14 @@ module Sprockets
       "#<#{self.class} local=#{@fetch_cache.inspect} store=#{@cache_wrapper.cache.inspect}>"
     end
 
+    # Public: Clear cache
+    #
+    # Returns truthy on success, potentially raises exception on failure
+    def clear(options=nil)
+      @cache_wrapper.clear
+      @fetch_cache.clear
+    end
+
     private
       # Internal: Expand object cache key into a short String key.
       #
@@ -211,6 +226,16 @@ module Sprockets
         def set(key, value)
           cache.set(key, value)
         end
+
+        def clear(options=nil)
+          # dalli has a #flush method so try it
+          if cache.respond_to?(:flush)
+            cache.flush(options)
+          else
+            cache.clear(options)
+          end
+          true
+        end
       end
 
       class HashWrapper < Wrapper
@@ -221,6 +246,11 @@ module Sprockets
         def set(key, value)
           cache[key] = value
         end
+
+        def clear(options=nil)
+          cache.clear
+          true
+        end
       end
 
       class ReadWriteWrapper < Wrapper
@@ -231,6 +261,11 @@ module Sprockets
         def set(key, value)
           cache.write(key, value)
         end
+
+        def clear(options=nil)
+          cache.clear(options)
+          true
+        end
       end
   end
 end

data/lib/sprockets/cached_environment.rb

@@ -1,26 +1,26 @@
+# frozen_string_literal: true
 require 'sprockets/base'
 
 module Sprockets
-  # `Cached` is a special cached version of `Environment`.
+  # `CachedEnvironment` 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 `Cached` much faster. This
+  # The exception is that all of its file system methods are cached
+  # for the instances lifetime. This makes `CachedEnvironment` much faster. This
   # behavior is ideal in production environments where the file system
   # is immutable.
   #
-  # `Cached` should not be initialized directly. Instead use
+  # `CachedEnvironment` should not be initialized directly. Instead use
   # `Environment#cached`.
   class CachedEnvironment < Base
     def initialize(environment)
       initialize_configuration(environment)
 
       @cache   = environment.cache
-      @stats   = Hash.new { |h, k| h[k] = _stat(k) }
-      @entries = Hash.new { |h, k| h[k] = _entries(k) }
-      @uris    = Hash.new { |h, k| h[k] = _load(k) }
-
-      @processor_cache_keys  = Hash.new { |h, k| h[k] = _processor_cache_key(k) }
-      @resolved_dependencies = Hash.new { |h, k| h[k] = _resolve_dependency(k) }
+      @stats   = Concurrent::Map.new
+      @entries = Concurrent::Map.new
+      @uris    = Concurrent::Map.new
+      @processor_cache_keys = Concurrent::Map.new
+      @resolved_dependencies = Concurrent::Map.new
     end
 
     # No-op return self as cached environment.
@@ -30,33 +30,28 @@ module Sprockets
     alias_method :index, :cached
 
     # Internal: Cache Environment#entries
-    alias_method :_entries, :entries
     def entries(path)
-      @entries[path]
+      @entries.fetch_or_store(path) { super(path) }
     end
 
     # Internal: Cache Environment#stat
-    alias_method :_stat, :stat
     def stat(path)
-      @stats[path]
+      @stats.fetch_or_store(path) { super(path) }
     end
 
     # Internal: Cache Environment#load
-    alias_method :_load, :load
     def load(uri)
-      @uris[uri]
+      @uris.fetch_or_store(uri) { super(uri) }
     end
 
     # Internal: Cache Environment#processor_cache_key
-    alias_method :_processor_cache_key, :processor_cache_key
     def processor_cache_key(str)
-      @processor_cache_keys[str]
+      @processor_cache_keys.fetch_or_store(str) { super(str) }
     end
 
     # Internal: Cache Environment#resolve_dependency
-    alias_method :_resolve_dependency, :resolve_dependency
     def resolve_dependency(str)
-      @resolved_dependencies[str]
+      @resolved_dependencies.fetch_or_store(str) { super(str) }
     end
 
     private

data/lib/sprockets/closure_compressor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sprockets/autoload'
 require 'sprockets/digest_utils'
 

data/lib/sprockets/coffee_script_processor.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
 require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
 
 module Sprockets
   # Processor engine class for the CoffeeScript compiler.
   # Depends on the `coffee-script` and `coffee-script-source` gems.
   #
-  # For more infomation see:
+  # For more information see:
   #
-  #   https://github.com/josh/ruby-coffee-script
+  #   https://github.com/rails/ruby-coffee-script
   #
   module CoffeeScriptProcessor
-    VERSION = '1'
+    VERSION = '2'
 
     def self.cache_key
       @cache_key ||= "#{name}:#{Autoload::CoffeeScript::Source.version}:#{VERSION}".freeze
@@ -17,9 +19,21 @@ module Sprockets
 
     def self.call(input)
       data = input[:data]
-      input[:cache].fetch([self.cache_key, data]) do
-        Autoload::CoffeeScript.compile(data)
+
+      js, map = input[:cache].fetch([self.cache_key, data, input[:filename]]) do
+        result = Autoload::CoffeeScript.compile(
+          data,
+          sourceMap: "v3",
+          sourceFiles: [File.basename(input[:filename])],
+          generatedFile: input[:filename]
+        )
+        [result['js'], JSON.parse(result['v3SourceMap'])]
       end
+
+      map = SourceMapUtils.format_source_map(map, input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
+      { data: js, map: map }
     end
   end
 end

data/lib/sprockets/compressing.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sprockets/utils'
 
 module Sprockets
@@ -10,6 +11,24 @@ module Sprockets
       config[:compressors]
     end
 
+    # Public: Register a new compressor `klass` at `sym` for `mime_type`.
+    #
+    # Registering a processor allows it to be looked up by `sym` later when
+    # assigning a JavaScript or CSS compressor.
+    #
+    # Compressors only operate on JavaScript and CSS. If you want to compress a
+    # different type of asset, use a processor instead.
+    #
+    # Examples
+    #
+    #     register_compressor 'text/css', :my_sass, MySassCompressor
+    #     css_compressor = :my_sass
+    #
+    # mime_type - String MIME Type (one of: 'test/css' or 'application/javascript').
+    # sym       - Symbol registration address.
+    # klass     - The compressor class.
+    #
+    # Returns nothing.
     def register_compressor(mime_type, sym, klass)
       self.config = hash_reassoc(config, :compressors, mime_type) do |compressors|
         compressors[sym] = klass
@@ -35,7 +54,7 @@ module Sprockets
       if compressor.is_a?(Symbol)
         @css_compressor = klass = config[:compressors]['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
       elsif compressor.respond_to?(:compress)
-        klass = LegacyProcProcessor.new(:css_compressor, proc { |context, data| compressor.compress(data) })
+        klass = proc { |input| compressor.compress(input[:data]) }
         @css_compressor = :css_compressor
       else
         @css_compressor = klass = compressor
@@ -62,7 +81,7 @@ module Sprockets
       if compressor.is_a?(Symbol)
         @js_compressor = klass = config[:compressors]['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
       elsif compressor.respond_to?(:compress)
-        klass = LegacyProcProcessor.new(:js_compressor, proc { |context, data| compressor.compress(data) })
+        klass = proc { |input| compressor.compress(input[:data]) }
         @js_compressor = :js_compressor
       else
         @js_compressor = klass = compressor
@@ -83,12 +102,33 @@ module Sprockets
 
     # Public: Enable or disable the creation of Gzip files.
     #
-    # Defaults to true.
+    # To disable gzip generation set to a falsey value:
     #
     #     environment.gzip = false
     #
+    # To enable set to a truthy value. By default zlib wil
+    # be used to gzip assets. If you have the Zopfli gem
+    # installed you can specify the zopfli algorithm to be used
+    # instead:
+    #
+    #     environment.gzip = :zopfli
+    #
     def gzip=(gzip)
       self.config = config.merge(gzip_enabled: gzip).freeze
+
+      case gzip
+      when false, nil
+        self.unregister_exporter Exporters::ZlibExporter
+        self.unregister_exporter Exporters::ZopfliExporter
+      when :zopfli
+        self.unregister_exporter Exporters::ZlibExporter
+        self.register_exporter '*/*', Exporters::ZopfliExporter
+      else
+        self.unregister_exporter Exporters::ZopfliExporter
+        self.register_exporter '*/*', Exporters::ZlibExporter
+      end
+
+      gzip
     end
   end
 end

data/lib/sprockets/configuration.rb

@@ -1,27 +1,25 @@
+# frozen_string_literal: true
 require 'sprockets/compressing'
 require 'sprockets/dependencies'
-require 'sprockets/engines'
 require 'sprockets/mime'
 require 'sprockets/paths'
 require 'sprockets/processing'
+require 'sprockets/exporting'
 require 'sprockets/transformers'
 require 'sprockets/utils'
 
 module Sprockets
   module Configuration
-    include Paths, Mime, Engines, Transformers, Processing, Compressing, Dependencies, Utils
+    include Paths, Mime, Transformers, Processing, Exporting, Compressing, Dependencies, Utils
 
     def initialize_configuration(parent)
       @config = parent.config
-      @computed_config = parent.computed_config
       @logger = parent.logger
       @context_class = Class.new(parent.context_class)
     end
 
     attr_reader :config
 
-    attr_accessor :computed_config
-
     def config=(config)
       raise TypeError, "can't assign mutable config" unless config.frozen?
       @config = config
@@ -61,16 +59,14 @@ module Sprockets
 
     # Deprecated: Assign a `Digest` implementation class. This maybe any Ruby
     # `Digest::` implementation such as `Digest::SHA256` or
-    # `Digest::MD5`.
+    # `Digest::SHA512`.
     #
-    #     environment.digest_class = Digest::MD5
+    #     environment.digest_class = Digest::SHA512
     #
     def digest_class=(klass)
       self.config = config.merge(digest_class: klass).freeze
     end
 
-    # Deprecated: Get `Context` class.
-    #
     # This class maybe mutated and mixed in with custom helpers.
     #
     #     environment.context_class.instance_eval do