sprockets 3.7.2 → 4.1.1

data/lib/sprockets/erb_processor.rb

@@ -1,30 +1,43 @@
+# 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)
+    if keyword_constructor? # 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
+
+  private
+
+  def keyword_constructor?
+    return @keyword_constructor if defined? @keyword_constructor
+    @keyword_constructor = ::ERB.instance_method(:initialize).parameters.include?([:key, :trim_mode])
   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
+    # Convenience 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 initialization
+      #
+      # 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

data/lib/sprockets/jst_processor.rb

@@ -1,21 +1,22 @@
+# frozen_string_literal: true
 module Sprockets
-  # Public: .jst engine.
+  # Public: JST transformer.
   #
   # Exports server side compiled templates to an object.
   #
-  # Name your template "users/show.jst.ejs", "users/new.jst.eco", etc.
+  # Name your template "users/show.ejs", "users/new.eco", etc.
   #
   # To accept the default options
   #
-  #     environment.register_engine '.jst',
-  #       JstProcessor,
-  #       mime_type: 'application/javascript'
+  #     environment.register_transformer
+  #       'application/javascript+function',
+  #       'application/javascript', JstProcessor
   #
   # Change the default namespace.
   #
-  #     environment.register_engine '.jst',
-  #       JstProcessor.new(namespace: 'App.templates'),
-  #       mime_type: 'application/javascript'
+  #     environment.register_transformer
+  #       'application/javascript+function',
+  #       'application/javascript', JstProcessor.new(namespace: 'App.templates')
   #
   class JstProcessor
     def self.default_namespace
@@ -33,8 +34,8 @@ module Sprockets
       instance.call(input)
     end
 
-    def initialize(options = {})
-      @namespace = options[:namespace] || self.class.default_namespace
+    def initialize(namespace: self.class.default_namespace)
+      @namespace = namespace
     end
 
     def call(input)