sprockets 3.7.2 → 4.0.2

data/lib/sprockets/dependencies.rb

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

data/lib/sprockets/digest_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'digest/md5'
 require 'digest/sha1'
 require 'digest/sha2'
@@ -62,7 +63,7 @@ module Sprockets
       },
       Set => ->(val, digest) {
         digest << 'Set'.freeze
-        ADD_VALUE_TO_DIGEST[Array].call(val.to_a, digest)
+        ADD_VALUE_TO_DIGEST[Array].call(val, digest)
       },
       Encoding => ->(val, digest) {
         digest << 'Encoding'.freeze
@@ -79,6 +80,9 @@ module Sprockets
         digest << val.to_s
       }
     end
+
+    ADD_VALUE_TO_DIGEST.compare_by_identity.rehash
+
     ADD_VALUE_TO_DIGEST.default_proc = ->(_, val) {
       raise TypeError, "couldn't digest #{ val }"
     }
@@ -93,10 +97,18 @@ module Sprockets
     #
     # Returns a String digest of the object.
     def digest(obj)
-      digest = digest_class.new
+      build_digest(obj).digest
+    end
 
-      ADD_VALUE_TO_DIGEST[obj.class].call(obj, digest)
-      digest.digest
+    # Internal: Generate a hexdigest for a nested JSON serializable object.
+    #
+    # The same as `pack_hexdigest(digest(obj))`.
+    #
+    # obj - A JSON serializable object.
+    #
+    # Returns a String digest of the object.
+    def hexdigest(obj)
+      build_digest(obj).hexdigest!
     end
 
     # Internal: Pack a binary digest to a hex encoded string.
@@ -105,7 +117,7 @@ module Sprockets
     #
     # Returns hex String.
     def pack_hexdigest(bin)
-      bin.unpack('H*').first
+      bin.unpack('H*'.freeze).first
     end
 
     # Internal: Unpack a hex encoded digest string into binary bytes.
@@ -176,5 +188,13 @@ module Sprockets
     def hexdigest_integrity_uri(hexdigest)
       integrity_uri(unpack_hexdigest(hexdigest))
     end
+
+    private
+      def build_digest(obj)
+        digest = digest_class.new
+
+        ADD_VALUE_TO_DIGEST[obj.class].call(obj, digest)
+        digest
+      end
   end
 end

data/lib/sprockets/directive_processor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'set'
 require 'shellwords'
 
@@ -34,8 +35,6 @@ module Sprockets
   #     env.register_processor('text/css', MyProcessor)
   #
   class DirectiveProcessor
-    VERSION = '1'
-
     # Directives are denoted by a `=` followed by the name, then
     # argument list.
     #
@@ -50,18 +49,16 @@ module Sprockets
     /x
 
     def self.instance
-      @instance ||= new(
-        # Deprecated: Default to C and Ruby comment styles
-        comments: ["//", ["/*", "*/"]] + ["#", ["###", "###"]]
-      )
+      # Default to C comment styles
+      @instance ||= new(comments: ["//", ["/*", "*/"]])
     end
 
     def self.call(input)
       instance.call(input)
     end
 
-    def initialize(options = {})
-      @header_pattern = compile_header_pattern(Array(options[:comments]))
+    def initialize(comments: [])
+      @header_pattern = compile_header_pattern(Array(comments))
     end
 
     def call(input)
@@ -73,20 +70,28 @@ module Sprockets
       @uri          = input[:uri]
       @filename     = input[:filename]
       @dirname      = File.dirname(@filename)
-      @content_type = input[:content_type]
+      # If loading a source map file like `application.js.map` resolve
+      # dependencies using `.js` instead of `.js.map`
+      @content_type = SourceMapProcessor.original_content_type(input[:content_type], error_when_not_found: false)
       @required     = Set.new(input[:metadata][:required])
       @stubbed      = Set.new(input[:metadata][:stubbed])
       @links        = Set.new(input[:metadata][:links])
       @dependencies = Set.new(input[:metadata][:dependencies])
+      @to_link      = Set.new
+      @to_load      = Set.new
 
       data, directives = process_source(input[:data])
       process_directives(directives)
 
-      { data: data,
-        required: @required,
-        stubbed: @stubbed,
-        links: @links,
-        dependencies: @dependencies }
+      {
+        data:         data,
+        required:     @required,
+        stubbed:      @stubbed,
+        links:        @links,
+        to_load:      @to_load,
+        to_link:      @to_link,
+        dependencies: @dependencies
+      }
     end
 
     protected
@@ -116,9 +121,9 @@ module Sprockets
 
         header, directives = extract_directives(header)
 
-        data = ""
+        data = +""
         data.force_encoding(body.encoding)
-        data << header << "\n" unless header.empty?
+        data << header unless header.empty?
         data << body
         # Ensure body ends in a new line
         data << "\n" if data.length > 0 && data[-1] != "\n"
@@ -134,7 +139,7 @@ module Sprockets
       #     [[1, "require", "foo"], [2, "require", "bar"]]
       #
       def extract_directives(header)
-        processed_header = ""
+        processed_header = +""
         directives = []
 
         header.lines.each_with_index do |line, index|
@@ -149,7 +154,11 @@ module Sprockets
           processed_header << line
         end
 
-        return processed_header.chomp, directives
+        processed_header.chomp!
+        # Ensure header ends in a new line like before it was processed
+        processed_header << "\n" if processed_header.length > 0 && header[-1] == "\n"
+
+        return processed_header, directives
       end
 
       # Gathers comment directives in the source and processes them.
@@ -162,7 +171,7 @@ module Sprockets
       # `process_require_glob_directive`.
       #
       #     class DirectiveProcessor < Sprockets::DirectiveProcessor
-      #       def process_require_glob_directive
+      #       def process_require_glob_directive(glob)
       #         Dir["#{dirname}/#{glob}"].sort.each do |filename|
       #           require(filename)
       #         end
@@ -187,7 +196,7 @@ module Sprockets
 
       # 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.
+      # and ensures it's only loaded once before the source file.
       #
       # `require` works with files in the environment path:
       #
@@ -265,15 +274,15 @@ module Sprockets
       # it.
       #
       # This is used for caching purposes. Any changes that would
-      # invalid the asset dependency will invalidate the cache our the
-      # source file.
+      # invalidate the asset dependency will invalidate the cache of
+      # 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)
-        load(resolve(path))
+        to_load(resolve(path))
       end
 
       # Allows dependency to be excluded from the asset bundle.
@@ -297,7 +306,8 @@ module Sprockets
       #   /*= link "logo.png" */
       #
       def process_link_directive(path)
-        @links << load(resolve(path)).uri
+        uri = to_load(resolve(path))
+        @to_link << uri
       end
 
       # `link_directory` links all the files inside a single
@@ -307,7 +317,7 @@ module Sprockets
       #     //= link_directory "./fonts"
       #
       # Use caution when linking against JS or CSS assets. Include an explicit
-      # extension or content type in these cases
+      # extension or content type in these cases.
       #
       #     //= link_directory "./scripts" .js
       #
@@ -323,7 +333,7 @@ module Sprockets
       #     //= link_tree "./images"
       #
       # Use caution when linking against JS or CSS assets. Include an explicit
-      # extension or content type in these cases
+      # extension or content type in these cases.
       #
       #     //= link_tree "./styles" .css
       #
@@ -354,15 +364,15 @@ module Sprockets
 
       def link_paths(paths, deps, accept)
         resolve_paths(paths, deps, accept: accept) do |uri|
-          @links << load(uri).uri
+          @to_link << to_load(uri)
         end
       end
 
-      def resolve_paths(paths, deps, options = {})
+      def resolve_paths(paths, deps, **kargs)
         @dependencies.merge(deps)
         paths.each do |subpath, stat|
           next if subpath == @filename || stat.directory?
-          uri, deps = @environment.resolve(subpath, options.merge(compat: false))
+          uri, deps = @environment.resolve(subpath, **kargs)
           @dependencies.merge(deps)
           yield uri if uri
         end
@@ -384,19 +394,19 @@ module Sprockets
         end
       end
 
-      def load(uri)
-        asset = @environment.load(uri)
-        @dependencies.merge(asset.metadata[:dependencies])
-        asset
+      def to_load(uri)
+        @to_load << uri
+        uri
       end
 
-      def resolve(path, options = {})
+      def resolve(path, **kargs)
         # Prevent absolute paths in directives
         if @environment.absolute_path?(path)
           raise FileOutsidePaths, "can't require absolute file: #{path}"
         end
 
-        uri, deps = @environment.resolve!(path, options.merge(base_path: @dirname))
+        kargs[:base_path] = @dirname
+        uri, deps = @environment.resolve!(path, **kargs)
         @dependencies.merge(deps)
         uri
       end

data/lib/sprockets/eco_processor.rb

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

data/lib/sprockets/ejs_processor.rb

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

data/lib/sprockets/encoding_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'base64'
 require 'stringio'
 require 'zlib'

data/lib/sprockets/environment.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require 'sprockets/base'
 require 'sprockets/cache/memory_store'
 require 'sprockets/cached_environment'
 
 module Sprockets
   class Environment < Base
-    # `Environment` should initialized with your application's root
+    # `Environment` should be initialized with your application's root
     # directory. This should be the same as your Rails or Rack root.
     #
     #     env = Environment.new(Rails.root)
@@ -18,7 +19,7 @@ module Sprockets
 
     # Returns a cached version of the environment.
     #
-    # All its file system calls are cached which makes `cached` much
+    # All of its file system calls are cached which makes `cached` much
     # faster. This behavior is ideal in production since the file
     # system only changes between deploys.
     def cached
@@ -26,8 +27,12 @@ module Sprockets
     end
     alias_method :index, :cached
 
-    def find_asset(*args)
-      cached.find_asset(*args)
+    def find_asset(*args, **options)
+      cached.find_asset(*args, **options)
+    end
+
+    def find_asset!(*args)
+      cached.find_asset!(*args)
     end
 
     def find_all_linked_assets(*args, &block)

data/lib/sprockets/erb_processor.rb

@@ -1,30 +1,37 @@
+# frozen_string_literal: true
 require 'erb'
 
-module Sprockets
-  class ERBProcessor
-    # Public: Return singleton instance with default options.
-    #
-    # Returns ERBProcessor object.
-    def self.instance
-      @instance ||= new
-    end
+class Sprockets::ERBProcessor
+  # Public: Return singleton instance with default options.
+  #
+  # Returns ERBProcessor object.
+  def self.instance
+    @instance ||= new
+  end
 
-    def self.call(input)
-      instance.call(input)
-    end
+  def self.call(input)
+    instance.call(input)
+  end
 
-    def initialize(&block)
-      @block = block
-    end
+  def initialize(&block)
+    @block = block
+  end
 
-    def call(input)
+  def call(input)
+    match = ERB.version.match(/\Aerb\.rb \[(?<version>[^ ]+) /)
+    if match && match[:version] >= "2.2.0" # Ruby 2.6+
+      engine = ::ERB.new(input[:data], trim_mode: '<>')
+    else
       engine = ::ERB.new(input[:data], nil, '<>')
-      context = input[:environment].context_class.new(input)
-      klass = (class << context; self; end)
-      klass.class_eval(&@block) if @block
-      engine.def_method(klass, :_evaluate_template, input[:filename])
-      data = context._evaluate_template
-      context.metadata.merge(data: data)
     end
+    engine.filename = input[:filename]
+
+    context = input[:environment].context_class.new(input)
+    klass = (class << context; self; end)
+    klass.const_set(:ENV, context.env_proxy)
+    klass.class_eval(&@block) if @block
+
+    data = engine.result(context.instance_eval('binding'))
+    context.metadata.merge(data: data)
   end
 end

data/lib/sprockets/errors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Define some basic Sprockets error classes
 module Sprockets
   class Error           < StandardError; end

data/lib/sprockets/exporters/base.rb

@@ -0,0 +1,71 @@
+module Sprockets
+  module Exporters
+    # Convienence class for all exporters to inherit from
+    #
+    # An exporter is responsible for exporting a Sprockets::Asset
+    # to a file system. For example the Exporters::File class
+    # writes the asset to it's destination. The Exporters::Zlib class
+    # writes a gzip copy of the asset to disk.
+    class Base
+      attr_reader :asset, :environment, :directory, :target
+
+      # Public: Creates new instance
+      #
+      # Initialize will be called with
+      # keyword arguments:
+      #
+      # - asset: An instance of Sprockets::Asset.
+      # - environment: An instance of Sprockets::Environment.
+      # - directory: String representing the target directory to write to.
+      #
+      # These will all be stored as accessible values. In addition a
+      # +target+ will be available which is the target directory and
+      # the asset's digest path combined.
+      def initialize(asset: nil, environment: nil, directory: nil)
+        @asset       = asset
+        @environment = environment
+        @directory   = directory
+        @target      = ::File.join(directory, asset.digest_path)
+        setup
+      end
+
+      # Public: Callback that is executed after intialization
+      #
+      # Any setup that needs to be done can be performed in the +setup+
+      # method. It will be called immediately after initialization.
+      def setup
+      end
+
+      # Public: Handles logic for skipping exporter and notifying logger
+      #
+      # The `skip?` will be called before anything will be written.
+      # If `skip?` returns truthy it will not continue. This method
+      # takes a `logger` that responds to +debug+ and +info+.  The `skip?`
+      # method is the only place expected to write to a logger, any other
+      # messages may produce jumbled logs.
+      def skip?(logger)
+        false
+      end
+
+      # Public: Contains logic for writing "exporting" asset to disk
+      #
+      # If the exporter is not skipped it then Sprockets will execute it's
+      # `call` method. This method takes no arguments and should only use
+      # elements passed in via initialize or stored in `setup`.
+      def call
+        raise "Must subclass and implement call"
+      end
+
+      # Public: Yields a file that can be written to with the input
+      #
+      # `filename`. Defaults to the `target`. Method
+      # is safe to use in forked or threaded environments.
+      def write(filename = target)
+        FileUtils.mkdir_p File.dirname(filename)
+        PathUtils.atomic_write(filename) do |f|
+          yield f
+        end
+      end
+    end
+  end
+end