sprockets 3.7.2 → 4.1.1

data/lib/sprockets/path_dependency_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'set'
 require 'sprockets/path_utils'
 require 'sprockets/uri_utils'
@@ -41,7 +42,7 @@ module Sprockets
     #
     # Returns an Array of entry names and a Set of dependency URIs.
     def entries_with_dependencies(path)
-      return entries(path), file_digest_dependency_set(path)
+      return entries(path), Set.new([build_file_digest_uri(path)])
     end
 
     # Internal: List directory filenames and associated Stats under a
@@ -53,16 +54,7 @@ module Sprockets
     #
     # Returns an Array of filenames and a Set of dependency URIs.
     def stat_directory_with_dependencies(dir)
-      return stat_directory(dir).to_a, file_digest_dependency_set(dir)
-    end
-
-    # Internal: Returns a set of dependencies for a particular path.
-    #
-    # path - String directory path
-    #
-    # Returns a Set of dependency URIs.
-    def file_digest_dependency_set(path)
-      Set.new([build_file_digest_uri(path)])
+      return stat_directory(dir).to_a, Set.new([build_file_digest_uri(dir)])
     end
 
     # Internal: List directory filenames and associated Stats under an entire

data/lib/sprockets/path_digest_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sprockets/digest_utils'
 require 'sprockets/path_utils'
 
@@ -15,7 +16,7 @@ module Sprockets
     def stat_digest(path, stat)
       if stat.directory?
         # If its a directive, digest the list of filenames
-        digest_class.digest(self.entries(path).join(','))
+        digest_class.digest(self.entries(path).join(','.freeze))
       elsif stat.file?
         # If its a file, digest the contents
         digest_class.file(path.to_s).digest

data/lib/sprockets/path_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sprockets
   # Internal: File and path related utilities. Mixed into Environment.
   #
@@ -5,6 +6,7 @@ module Sprockets
   # when code actually wants to reference ::FileUtils.
   module PathUtils
     extend self
+    require 'pathname'
 
     # Public: Like `File.stat`.
     #
@@ -53,13 +55,14 @@ module Sprockets
     # Returns an empty `Array` if the directory does not exist.
     def entries(path)
       if File.directory?(path)
-        entries = Dir.entries(path, :encoding => Encoding.default_internal)
+        entries = Dir.entries(path, encoding: Encoding.default_internal)
         entries.reject! { |entry|
           entry.start_with?(".".freeze) ||
             (entry.start_with?("#".freeze) && entry.end_with?("#".freeze)) ||
             entry.end_with?("~".freeze)
         }
         entries.sort!
+        entries
       else
         []
       end
@@ -71,8 +74,6 @@ module Sprockets
     #
     # Returns true if path is absolute, otherwise false.
     if File::ALT_SEPARATOR
-      require 'pathname'
-
       # On Windows, ALT_SEPARATOR is \
       # Delegate to Pathname since the logic gets complex.
       def absolute_path?(path)
@@ -80,7 +81,7 @@ module Sprockets
       end
     else
       def absolute_path?(path)
-        path[0] == File::SEPARATOR
+        path.start_with?(File::SEPARATOR)
       end
     end
 
@@ -97,7 +98,58 @@ module Sprockets
     #
     # Returns true if path is relative, otherwise false.
     def relative_path?(path)
-      path =~ /^\.\.?($|#{SEPARATOR_PATTERN})/ ? true : false
+      path.match?(/^\.\.?($|#{SEPARATOR_PATTERN})/) ? true : false
+    end
+
+    # Public: Get relative path from `start` to `dest`.
+    #
+    # start - String start path (file or dir)
+    # dest  - String destination path
+    #
+    # Returns relative String path from `start` to `dest`
+    def relative_path_from(start, dest)
+      start, dest = Pathname.new(start), Pathname.new(dest)
+      start = start.dirname unless start.directory?
+      dest.relative_path_from(start).to_s
+    end
+
+    # Public: Joins path to base path.
+    #
+    # base - Root path
+    # path - Extending path
+    #
+    # Example
+    #
+    #     join('base/path/', '../file.js')
+    #     # => 'base/file.js'
+    #
+    # Returns string path starting from base and ending at path
+    def join(base, path)
+      (Pathname.new(base) + path).to_s
+    end
+
+    # Public: Sets pipeline for path
+    #
+    # path       - String path
+    # extensions - List of file extensions
+    # pipeline   - Pipeline
+    #
+    # Examples
+    #
+    #     set_pipeline('path/file.js.erb', config[:mime_exts], config[:pipeline_exts], :source)
+    #     # => 'path/file.source.js.erb'
+    #
+    #     set_pipeline('path/some.file.source.js.erb', config[:mime_exts], config[:pipeline_exts], :debug)
+    #     # => 'path/some.file.debug.js.erb'
+    #
+    # Returns string path with pipeline parsed in
+    def set_pipeline(path, mime_exts, pipeline_exts, pipeline)
+      extension, _ = match_path_extname(path, mime_exts)
+      path.chomp!(extension)
+      pipeline_old, _ = match_path_extname(path, pipeline_exts)
+      path.chomp!(pipeline_old)
+
+      "#{path}.#{pipeline}#{extension}"
     end
 
     # Internal: Get relative path for root path and subpath.
@@ -109,8 +161,8 @@ module Sprockets
     # subpath is outside of path.
     def split_subpath(path, subpath)
       return "" if path == subpath
-      path = File.join(path, '')
-      if subpath.start_with?(path)
+      path = File.join(path, ''.freeze)
+      if subpath&.start_with?(path)
         subpath[path.length..-1]
       else
         nil
@@ -163,6 +215,34 @@ module Sprockets
       nil
     end
 
+    # Internal: Match paths in a directory against available extensions.
+    #
+    # path       - String directory
+    # basename   - String basename of target file
+    # extensions - Hash of String extnames to values
+    #
+    # Examples
+    #
+    #     exts = { ".js" => "application/javascript" }
+    #     find_matching_path_for_extensions("app/assets", "application", exts)
+    #     # => ["app/assets/application.js", "application/javascript"]
+    #
+    # Returns an Array of [String path, Object value] matches.
+    def find_matching_path_for_extensions(path, basename, extensions)
+      matches = []
+      entries(path).each do |entry|
+        next unless File.basename(entry).start_with?(basename)
+        extname, value = match_path_extname(entry, extensions)
+        if basename == entry.chomp(extname)
+          filename = File.join(path, entry)
+          if file?(filename)
+            matches << [filename, value]
+          end
+        end
+      end
+      matches
+    end
+
     # Internal: Returns all parents for path
     #
     # path - String absolute filename or directory
@@ -272,7 +352,7 @@ module Sprockets
         Thread.current.object_id,
         Process.pid,
         rand(1000000)
-      ].join('.')
+      ].join('.'.freeze)
       tmpname = File.join(dirname, basename)
 
       File.open(tmpname, 'wb+') do |f|

data/lib/sprockets/paths.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sprockets/path_utils'
 require 'sprockets/utils'
 

data/lib/sprockets/preprocessors/default_source_map.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Sprockets
+  module Preprocessors
+    # Private: Adds a default map to assets when one is not present
+    #
+    # If the input file already has a source map, it effectively returns the original
+    # result. Otherwise it maps 1 for 1 lines original to generated. This is needed
+    # Because other generators run after might depend on having a valid source map
+    # available.
+    class DefaultSourceMap
+      def call(input)
+        result        = { data: input[:data] }
+        map           = input[:metadata][:map]
+        filename      = input[:filename]
+        load_path     = input[:load_path]
+        lines         = input[:data].lines.length
+        basename      = File.basename(filename)
+        mime_exts     = input[:environment].config[:mime_exts]
+        pipeline_exts = input[:environment].config[:pipeline_exts]
+        if map.nil? || map.empty?
+          result[:map] = {
+            "version"   => 3,
+            "file"      => PathUtils.split_subpath(load_path, filename),
+            "mappings"  => default_mappings(lines),
+            "sources"   => [PathUtils.set_pipeline(basename, mime_exts, pipeline_exts, :source)],
+            "names"     => []
+          }
+        else
+          result[:map] = map
+        end
+
+        result[:map]["x_sprockets_linecount"] = lines
+        return result
+      end
+
+      private
+
+      def default_mappings(lines)
+        if (lines == 0)
+          ""
+        elsif (lines == 1)
+          "AAAA"
+        else
+          "AAAA;" + "AACA;"*(lines - 2) + "AACA"
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/processing.rb

@@ -1,7 +1,5 @@
-require 'sprockets/engines'
+# frozen_string_literal: true
 require 'sprockets/file_reader'
-require 'sprockets/legacy_proc_processor'
-require 'sprockets/legacy_tilt_processor'
 require 'sprockets/mime'
 require 'sprockets/processor_utils'
 require 'sprockets/uri_utils'
@@ -17,9 +15,14 @@ module Sprockets
       config[:pipelines]
     end
 
+    # Registers a pipeline that will be called by `call_processor` method.
     def register_pipeline(name, proc = nil, &block)
       proc ||= block
 
+      self.config = hash_reassoc(config, :pipeline_exts) do |pipeline_exts|
+        pipeline_exts.merge(".#{name}".freeze => name.to_sym)
+      end
+
       self.config = hash_reassoc(config, :pipelines) do |pipelines|
         pipelines.merge(name.to_sym => proc)
       end
@@ -43,12 +46,13 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_preprocessor 'text/css', :my_processor do |context, data|
-    #       data.gsub(...)
+    #     register_preprocessor 'text/css' do |input|
+    #       input[:data].gsub(...)
     #     end
     #
     def register_preprocessor(*args, &block)
       register_config_processor(:preprocessors, *args, &block)
+      compute_transformers!(self.config[:registered_transformers])
     end
     alias_method :register_processor, :register_preprocessor
 
@@ -58,12 +62,13 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_postprocessor 'application/javascript', :my_processor do |context, data|
-    #       data.gsub(...)
+    #     register_postprocessor 'application/javascript' do |input|
+    #       input[:data].gsub(...)
     #     end
     #
     def register_postprocessor(*args, &block)
       register_config_processor(:postprocessors, *args, &block)
+      compute_transformers!(self.config[:registered_transformers])
     end
 
     # Remove Preprocessor `klass` for `mime_type`.
@@ -72,6 +77,7 @@ module Sprockets
     #
     def unregister_preprocessor(*args)
       unregister_config_processor(:preprocessors, *args)
+      compute_transformers!(self.config[:registered_transformers])
     end
     alias_method :unregister_processor, :unregister_preprocessor
 
@@ -81,6 +87,7 @@ module Sprockets
     #
     def unregister_postprocessor(*args)
       unregister_config_processor(:postprocessors, *args)
+      compute_transformers!(self.config[:registered_transformers])
     end
 
     # Bundle Processors are ran on concatenated assets rather than
@@ -95,8 +102,8 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_bundle_processor 'application/javascript', :my_processor do |context, data|
-    #       data.gsub(...)
+    #     register_bundle_processor 'application/javascript' do |input|
+    #       input[:data].gsub(...)
     #     end
     #
     def register_bundle_processor(*args, &block)
@@ -123,7 +130,7 @@ module Sprockets
     #
     # mime_type - String MIME Type. Use '*/*' applies to all types.
     # key       - Symbol metadata key
-    # initial   - Initial memo to pass to the reduce funciton (default: nil)
+    # initial   - Initial memo to pass to the reduce function (default: nil)
     # block     - Proc accepting the memo accumulator and current value
     #
     # Returns nothing.
@@ -154,46 +161,44 @@ module Sprockets
     protected
       def resolve_processors_cache_key_uri(uri)
         params = parse_uri_query_params(uri[11..-1])
-        params[:engine_extnames] = params[:engines] ? params[:engines].split(',') : []
-        processors = processors_for(params[:type], params[:file_type], params[:engine_extnames], params[:pipeline])
+        processors = processors_for(params[:type], params[:file_type], params[:pipeline])
         processors_cache_keys(processors)
       end
 
-      def build_processors_uri(type, file_type, engine_extnames, pipeline)
-        engines = engine_extnames.join(',') if engine_extnames.any?
+      def build_processors_uri(type, file_type, pipeline)
         query = encode_uri_query_params(
           type: type,
           file_type: file_type,
-          engines: engines,
           pipeline: pipeline
         )
         "processors:#{query}"
       end
 
-      def processors_for(type, file_type, engine_extnames, pipeline)
+      def processors_for(type, file_type, pipeline)
         pipeline ||= :default
-        config[:pipelines][pipeline.to_sym].call(self, type, file_type, engine_extnames)
+        if fn = config[:pipelines][pipeline.to_sym]
+          fn.call(self, type, file_type)
+        else
+          raise Error, "no pipeline: #{pipeline}"
+        end
       end
 
-      def default_processors_for(type, file_type, engine_extnames)
+      def default_processors_for(type, file_type)
         bundled_processors = config[:bundle_processors][type]
         if bundled_processors.any?
           bundled_processors
         else
-          self_processors_for(type, file_type, engine_extnames)
+          self_processors_for(type, file_type)
         end
       end
 
-      def self_processors_for(type, file_type, engine_extnames)
+      def self_processors_for(type, file_type)
         processors = []
 
         processors.concat config[:postprocessors][type]
-
         if type != file_type && processor = config[:transformers][file_type][type]
           processors << processor
         end
-
-        processors.concat engine_extnames.map { |ext| engines[ext] }
         processors.concat config[:preprocessors][file_type]
 
         if processors.any? || mime_type_charset_detecter(type)
@@ -204,55 +209,20 @@ module Sprockets
       end
 
     private
-      def register_config_processor(type, mime_type, klass, proc = nil, &block)
-        proc ||= block
-        processor = wrap_processor(klass, proc)
+      def register_config_processor(type, mime_type, processor = nil, &block)
+        processor ||= block
 
         self.config = hash_reassoc(config, type, mime_type) do |processors|
           processors.unshift(processor)
           processors
         end
-
-        compute_transformers!
       end
 
-      def unregister_config_processor(type, mime_type, klass)
-        if klass.is_a?(String) || klass.is_a?(Symbol)
-          klass = config[type][mime_type].detect do |cls|
-            cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
-          end
-        end
-
+      def unregister_config_processor(type, mime_type, processor)
         self.config = hash_reassoc(config, type, mime_type) do |processors|
-          processors.delete(klass)
+          processors.delete_if { |p| p == processor || p.class == processor }
           processors
         end
-
-        compute_transformers!
-      end
-
-      def deprecate_legacy_processor_interface(interface)
-        msg = "You are using a deprecated processor interface #{ interface.inspect }.\n" +
-        "Please update your processor interface:\n" +
-        "https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md#supporting-all-versions-of-sprockets-in-processors\n"
-
-        Deprecation.new([caller[3]]).warn msg
-      end
-
-      def wrap_processor(klass, proc)
-        if !proc
-          if klass.respond_to?(:call)
-            klass
-          else
-            deprecate_legacy_processor_interface(klass)
-            LegacyTiltProcessor.new(klass)
-          end
-        elsif proc.respond_to?(:arity) && proc.arity == 2
-          deprecate_legacy_processor_interface(proc)
-          LegacyProcProcessor.new(klass.to_s, proc)
-        else
-          proc
-        end
       end
   end
 end

data/lib/sprockets/processor_utils.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 require 'set'
 
 module Sprockets
   # Functional utilities for dealing with Processor functions.
   #
-  # A Processor is a general function that my modify or transform an asset as
+  # A Processor is a general function that may modify or transform an asset as
   # part of the pipeline. CoffeeScript to JavaScript conversion, Minification
-  # or Concatenation are all implemented as seperate Processor steps.
+  # or Concatenation are all implemented as separate Processor steps.
   #
   # Processors maybe any object that responds to call. So procs or a class that
   # defines a self.call method.
@@ -16,26 +17,34 @@ module Sprockets
   module ProcessorUtils
     extend self
 
+    class CompositeProcessor < Struct.new(:processor_strategy, :param, :processors) # :nodoc:
+      SINGULAR = lambda { |param, input| ProcessorUtils.call_processor param, input }
+      PLURAL   = lambda { |param, input| ProcessorUtils.call_processors param, input }
+
+      def self.create(processors)
+        if processors.length == 1
+          new SINGULAR, processors.first, processors
+        else
+          new PLURAL, processors, processors
+        end
+      end
+
+      def call(input)
+        processor_strategy.call param, input
+      end
+
+      def cache_key
+        ProcessorUtils.processors_cache_keys(processors)
+      end
+    end
+
     # Public: Compose processors in right to left order.
     #
     # processors - Array of processors callables
     #
     # Returns a composed Proc.
     def compose_processors(*processors)
-      context = self
-
-      if processors.length == 1
-        obj = method(:call_processor).to_proc.curry[processors.first]
-      else
-        obj = method(:call_processors).to_proc.curry[processors]
-      end
-
-      metaclass = (class << obj; self; end)
-      metaclass.send(:define_method, :cache_key) do
-        context.processors_cache_keys(processors)
-      end
-
-      obj
+      CompositeProcessor.create processors
     end
 
     # Public: Invoke list of processors in right to left order.
@@ -109,8 +118,9 @@ module Sprockets
       Symbol,
       TrueClass,
       FalseClass,
-      NilClass
-    ] + (0.class == Integer ? [Integer] : [Bignum, Fixnum])).freeze
+      NilClass,
+      Integer
+    ]).freeze
 
     # Internal: Set of all nested compound metadata types that can nest values.
     VALID_METADATA_COMPOUND_TYPES = Set.new([
@@ -152,29 +162,9 @@ module Sprockets
         if !key.instance_of?(Symbol)
           raise TypeError, "processor metadata[#{key.inspect}] expected to be a Symbol"
         end
-
-        if !valid_processor_metadata_value?(value)
-          raise TypeError, "processor metadata[:#{key}] returned a complex type: #{value.inspect}\n" +
-            "Only #{VALID_METADATA_TYPES.to_a.join(", ")} maybe used."
-        end
       end
 
       result
     end
-
-    # Internal: Validate object is in validate metadata whitelist.
-    #
-    # value - Any Object
-    #
-    # Returns true if class is in whitelist otherwise false.
-    def valid_processor_metadata_value?(value)
-      if VALID_METADATA_VALUE_TYPES_HASH[value.class]
-        true
-      elsif VALID_METADATA_COMPOUND_TYPES_HASH[value.class]
-        value.all? { |v| valid_processor_metadata_value?(v) }
-      else
-        false
-      end
-    end
   end
 end