sprockets 3.7.2 → 4.0.0

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,72 @@
+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
+

data/lib/sprockets/exporters/file_exporter.rb

@@ -0,0 +1,24 @@
+require 'sprockets/exporters/base'
+
+module Sprockets
+  module Exporters
+    # Writes a an asset file to disk
+    class FileExporter < Exporters::Base
+      def skip?(logger)
+        if ::File.exist?(target)
+          logger.debug "Skipping #{ target }, already exists"
+          true
+        else
+          logger.info "Writing #{ target }"
+          false
+        end
+      end
+
+      def call
+        write(target) do |file|
+          file.write(asset.source)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/exporters/zlib_exporter.rb

@@ -0,0 +1,33 @@
+require 'sprockets/exporters/base'
+require 'sprockets/utils/gzip'
+
+module Sprockets
+  module Exporters
+    # Generates a `.gz` file using the zlib algorithm built into
+    # Ruby's standard library.
+    class ZlibExporter < Exporters::Base
+      def setup
+        @gzip_target = "#{ target }.gz"
+        @gzip = Sprockets::Utils::Gzip.new(asset, archiver: Utils::Gzip::ZlibArchiver)
+      end
+
+      def skip?(logger)
+        return true if environment.skip_gzip?
+        return true if @gzip.cannot_compress?
+        if ::File.exist?(@gzip_target)
+          logger.debug "Skipping #{ @gzip_target }, already exists"
+          true
+        else
+          logger.info "Writing #{ @gzip_target }"
+          false
+        end
+      end
+
+      def call
+        write(@gzip_target) do |file|
+          @gzip.compress(file, target)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/exporters/zopfli_exporter.rb

@@ -0,0 +1,14 @@
+require 'sprockets/exporters/zlib_exporter'
+
+module Sprockets
+  module Exporters
+    # Generates a `.gz` file using the zopfli algorithm from the
+    # Zopfli gem.
+    class ZopfliExporter < ZlibExporter
+      def setup
+        @gzip_target = "#{ target }.gz"
+        @gzip = Sprockets::Utils::Gzip.new(asset, archiver: Utils::Gzip::ZopfliArchiver)
+      end
+    end
+  end
+end

data/lib/sprockets/exporting.rb

@@ -0,0 +1,73 @@
+module Sprockets
+  # `Exporting` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `CachedEnvironment` classes.
+  module Exporting
+    # Exporters are ran on the assets:precompile task
+    def exporters
+      config[:exporters]
+    end
+
+    # Public: Registers a new Exporter `klass` for `mime_type`.
+    #
+    # If your exporter depends on one or more other exporters you can
+    # specify this via the `depend_on` keyword.
+    #
+    #     register_exporter '*/*', Sprockets::Exporters::ZlibExporter
+    #
+    # This ensures that `Sprockets::Exporters::File` will always execute before
+    # `Sprockets::Exporters::Zlib`
+    def register_exporter(mime_types, klass = nil)
+      mime_types = Array(mime_types)
+
+      mime_types.each do |mime_type|
+        self.config = hash_reassoc(config, :exporters, mime_type) do |_exporters|
+          _exporters << klass
+        end
+      end
+    end
+
+    # Public: Remove Exporting processor `klass` for `mime_type`.
+    #
+    #     environment.unregister_exporter '*/*', Sprockets::Exporters::Zlib
+    #
+    # Can be called without a mime type
+    #
+    #     environment.unregister_exporter Sprockets::Exporters::Zlib
+    #
+    # Does not remove any exporters that depend on `klass`.
+    def unregister_exporter(mime_types, exporter = nil)
+      unless mime_types.is_a? Array
+        if mime_types.is_a? String
+          mime_types = [mime_types]
+        else # called with no mime type
+          exporter = mime_types
+          mime_types = nil
+        end
+      end
+
+      self.config = hash_reassoc(config, :exporters) do |_exporters|
+        _exporters.each do |mime_type, exporters_array|
+          next if mime_types && !mime_types.include?(mime_type)
+          if exporters_array.include? exporter
+            _exporters[mime_type] = exporters_array.dup.delete exporter
+          end
+        end
+      end
+    end
+
+    # Public: Checks if concurrent exporting is allowed
+    def export_concurrent
+      config[:export_concurrent]
+    end
+
+    # Public: Enable or disable the concurrently exporting files
+    #
+    # Defaults to true.
+    #
+    #     environment.export_concurrent = false
+    #
+    def export_concurrent=(export_concurrent)
+      self.config = config.merge(export_concurrent: export_concurrent).freeze
+    end
+  end
+end

data/lib/sprockets/file_reader.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'set'
 
 module Sprockets

data/lib/sprockets/http_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sprockets
   # Internal: HTTP URI utilities. Many adapted from Rack::Utils. Mixed into
   # Environment.
@@ -13,9 +14,9 @@ module Sprockets
     # Returns true if the given value is a mime match for the given mime match
     # specification, false otherwise.
     def match_mime_type?(value, matcher)
-      v1, v2 = value.split('/', 2)
-      m1, m2 = matcher.split('/', 2)
-      (m1 == '*' || v1 == m1) && (m2.nil? || m2 == '*' || m2 == v2)
+      v1, v2 = value.split('/'.freeze, 2)
+      m1, m2 = matcher.split('/'.freeze, 2)
+      (m1 == '*'.freeze || v1 == m1) && (m2.nil? || m2 == '*'.freeze || m2 == v2)
     end
 
     # Public: Return values from Hash where the key matches the mime type.
@@ -36,7 +37,22 @@ module Sprockets
 
     # Internal: Parse Accept header quality values.
     #
-    # Adapted from Rack::Utils#q_values.
+    # values - String e.g. "application/javascript"
+    #
+    # Adapted from Rack::Utils#q_values. Quality values are
+    # described in http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+    #
+    #    parse_q_values("application/javascript")
+    #      # => [["application/javascript", 1.0]]
+    #
+    #    parse_q_values("*/*")
+    #      # => [["*/*", 1.0]]
+    #
+    #    parse_q_values("text/plain; q=0.5, image/*")
+    #      # => [["text/plain", 0.5], ["image/*", 1.0]]
+    #
+    #    parse_q_values("application/javascript, text/css")
+    #      # => [["application/javascript", 1.0], ["text/css", 1.0]]
     #
     # Returns an Array of [String, Float].
     def parse_q_values(values)
@@ -70,14 +86,16 @@ module Sprockets
         raise TypeError, "unknown q_values type: #{q_values.class}"
       end
 
+      i = 0
       q_values.each do |accepted, quality|
         if match = available.find { |option| matcher.call(option, accepted) }
-          matches << [match, quality]
+          i += 1
+          matches << [-quality, i, match]
         end
       end
 
-      matches.sort_by! { |match, quality| -quality }
-      matches.map! { |match, quality| match }
+      matches.sort!
+      matches.map! { |_, _, match| match }
       matches
     end
 

data/lib/sprockets/jsminc_compressor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
+
+module Sprockets
+  class JSMincCompressor
+    VERSION = '1'
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {})
+      @compressor_class = Autoload::JSMinC
+      @cache_key = "#{self.class.name}:#{Autoload::JSMinC::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
+    end
+
+    def call(input)
+      @compressor_class.minify(input[:data])
+    end
+  end
+end