sprockets 2.3.2 → 3.0.0

data/lib/sprockets/processing.rb

@@ -1,80 +1,40 @@
 require 'sprockets/engines'
+require 'sprockets/file_reader'
+require 'sprockets/legacy_proc_processor'
+require 'sprockets/legacy_tilt_processor'
 require 'sprockets/mime'
-require 'sprockets/processor'
+require 'sprockets/processor_utils'
+require 'sprockets/uri_utils'
 require 'sprockets/utils'
 
 module Sprockets
   # `Processing` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
+  # the `Environment` and `CachedEnvironment` classes.
   module Processing
-    include Engines, Mime
-
-    # Register a new mime type.
-    def register_mime_type(mime_type, ext)
-      # Overrides the global behavior to expire the index
-      expire_index!
-      @trail.append_extension(ext)
-      super
-    end
+    include ProcessorUtils, URIUtils, Utils
 
-    # Returns an `Array` of format extension `String`s.
-    #
-    #     format_extensions
-    #     # => ['.js', '.css']
-    #
-    def format_extensions
-      @trail.extensions - @engines.keys
+    def pipelines
+      config[:pipelines]
     end
 
-    # Registers a new Engine `klass` for `ext`.
-    def register_engine(ext, klass)
-      # Overrides the global behavior to expire the index
-      expire_index!
-      add_engine_to_trail(ext, klass)
-      super
-    end
+    def register_pipeline(name, proc = nil, &block)
+      proc ||= block
 
-    # Deprecated alias for `preprocessors`.
-    def processors(*args)
-      preprocessors(*args)
+      self.config = hash_reassoc(config, :pipelines) do |pipelines|
+        pipelines.merge(name.to_sym => proc)
+      end
     end
 
-    # Returns an `Array` of `Processor` classes. If a `mime_type`
-    # argument is supplied, the processors registered under that
-    # extension will be returned.
-    #
     # Preprocessors are ran before Postprocessors and Engine
     # processors.
-    #
-    # All `Processor`s must follow the `Tilt::Template` interface. It is
-    # recommended to subclass `Tilt::Template`.
-    def preprocessors(mime_type = nil)
-      if mime_type
-        @preprocessors[mime_type].dup
-      else
-        deep_copy_hash(@preprocessors)
-      end
+    def preprocessors
+      config[:preprocessors]
     end
+    alias_method :processors, :preprocessors
 
-    # Returns an `Array` of `Processor` classes. If a `mime_type`
-    # argument is supplied, the processors registered under that
-    # extension will be returned.
-    #
     # Postprocessors are ran after Preprocessors and Engine processors.
-    #
-    # All `Processor`s must follow the `Tilt::Template` interface. It is
-    # recommended to subclass `Tilt::Template`.
-    def postprocessors(mime_type = nil)
-      if mime_type
-        @postprocessors[mime_type].dup
-      else
-        deep_copy_hash(@postprocessors)
-      end
-    end
-
-    # Deprecated alias for `register_preprocessor`.
-    def register_processor(*args, &block)
-      register_preprocessor(*args, &block)
+    def postprocessors
+      config[:postprocessors]
     end
 
     # Registers a new Preprocessor `klass` for `mime_type`.
@@ -83,197 +43,205 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_preprocessor :my_processor do |context, data|
+    #     register_preprocessor 'text/css', :my_processor do |context, data|
     #       data.gsub(...)
     #     end
     #
-    def register_preprocessor(mime_type, klass, &block)
-      expire_index!
-
-      if block_given?
-        name  = klass.to_s
-        klass = Class.new(Processor) do
-          @name      = name
-          @processor = block
-        end
-      end
-
-      @preprocessors[mime_type].push(klass)
+    def register_preprocessor(*args, &block)
+      register_config_processor(:preprocessors, *args, &block)
     end
+    alias_method :register_processor, :register_preprocessor
 
     # Registers a new Postprocessor `klass` for `mime_type`.
     #
-    #     register_postprocessor 'text/css', Sprockets::CharsetNormalizer
+    #     register_postprocessor 'application/javascript', Sprockets::DirectiveProcessor
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_postprocessor :my_processor do |context, data|
+    #     register_postprocessor 'application/javascript', :my_processor do |context, data|
     #       data.gsub(...)
     #     end
     #
-    def register_postprocessor(mime_type, klass, &block)
-      expire_index!
-
-      if block_given?
-        name  = klass.to_s
-        klass = Class.new(Processor) do
-          @name      = name
-          @processor = block
-        end
-      end
-
-      @postprocessors[mime_type].push(klass)
-    end
-
-    # Deprecated alias for `unregister_preprocessor`.
-    def unregister_processor(*args)
-      unregister_preprocessor(*args)
+    def register_postprocessor(*args, &block)
+      register_config_processor(:postprocessors, *args, &block)
     end
 
     # Remove Preprocessor `klass` for `mime_type`.
     #
     #     unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor
     #
-    def unregister_preprocessor(mime_type, klass)
-      expire_index!
-
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = @preprocessors[mime_type].detect { |cls|
-          cls.respond_to?(:name) &&
-            cls.name == "Sprockets::Processor (#{klass})"
-        }
-      end
-
-      @preprocessors[mime_type].delete(klass)
+    def unregister_preprocessor(*args)
+      unregister_config_processor(:preprocessors, *args)
     end
+    alias_method :unregister_processor, :unregister_preprocessor
 
     # Remove Postprocessor `klass` for `mime_type`.
     #
     #     unregister_postprocessor 'text/css', Sprockets::DirectiveProcessor
     #
-    def unregister_postprocessor(mime_type, klass)
-      expire_index!
-
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = @postprocessors[mime_type].detect { |cls|
-          cls.respond_to?(:name) &&
-            cls.name == "Sprockets::Processor (#{klass})"
-        }
-      end
-
-      @postprocessors[mime_type].delete(klass)
+    def unregister_postprocessor(*args)
+      unregister_config_processor(:postprocessors, *args)
     end
 
-    # Returns an `Array` of `Processor` classes. If a `mime_type`
-    # argument is supplied, the processors registered under that
-    # extension will be returned.
-    #
     # Bundle Processors are ran on concatenated assets rather than
     # individual files.
-    #
-    # All `Processor`s must follow the `Tilt::Template` interface. It is
-    # recommended to subclass `Tilt::Template`.
-    def bundle_processors(mime_type = nil)
-      if mime_type
-        @bundle_processors[mime_type].dup
-      else
-        deep_copy_hash(@bundle_processors)
-      end
+    def bundle_processors
+      config[:bundle_processors]
     end
 
     # Registers a new Bundle Processor `klass` for `mime_type`.
     #
-    #     register_bundle_processor  'text/css', Sprockets::CharsetNormalizer
+    #     register_bundle_processor  'application/javascript', Sprockets::DirectiveProcessor
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_bundle_processor :my_processor do |context, data|
+    #     register_bundle_processor 'application/javascript', :my_processor do |context, data|
     #       data.gsub(...)
     #     end
     #
-    def register_bundle_processor(mime_type, klass, &block)
-      expire_index!
-
-      if block_given?
-        name  = klass.to_s
-        klass = Class.new(Processor) do
-          @name      = name
-          @processor = block
-        end
-      end
-
-      @bundle_processors[mime_type].push(klass)
+    def register_bundle_processor(*args, &block)
+      register_config_processor(:bundle_processors, *args, &block)
     end
 
     # Remove Bundle Processor `klass` for `mime_type`.
     #
-    #     unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
+    #     unregister_bundle_processor 'application/javascript', Sprockets::DirectiveProcessor
     #
-    def unregister_bundle_processor(mime_type, klass)
-      expire_index!
-
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = @bundle_processors[mime_type].detect { |cls|
-          cls.respond_to?(:name) &&
-            cls.name == "Sprockets::Processor (#{klass})"
-        }
+    def unregister_bundle_processor(*args)
+      unregister_config_processor(:bundle_processors, *args)
+    end
+
+    # Public: Register bundle metadata reducer function.
+    #
+    # Examples
+    #
+    #   Sprockets.register_bundle_metadata_reducer 'application/javascript', :jshint_errors, [], :+
+    #
+    #   Sprockets.register_bundle_metadata_reducer 'text/css', :selector_count, 0 { |total, count|
+    #     total + count
+    #   }
+    #
+    # 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)
+    # block     - Proc accepting the memo accumulator and current value
+    #
+    # Returns nothing.
+    def register_bundle_metadata_reducer(mime_type, key, *args, &block)
+      case args.size
+      when 0
+        reducer = block
+      when 1
+        if block_given?
+          initial = args[0]
+          reducer = block
+        else
+          initial = nil
+          reducer = args[0].to_proc
+        end
+      when 2
+        initial = args[0]
+        reducer = args[1].to_proc
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0..2)"
       end
 
-      @bundle_processors[mime_type].delete(klass)
+      self.config = hash_reassoc(config, :bundle_reducers, mime_type) do |reducers|
+        reducers.merge(key => [initial, reducer])
+      end
     end
 
-    # Return CSS compressor or nil if none is set
-    def css_compressor
-      bundle_processors('text/css').detect { |klass|
-        klass.respond_to?(:name) &&
-          klass.name == 'Sprockets::Processor (css_compressor)'
-      }
-    end
+    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_cache_keys(processors)
+      end
 
-    # Assign a compressor to run on `text/css` assets.
-    #
-    # The compressor object must respond to `compress` or `compile`.
-    def css_compressor=(compressor)
-      expire_index!
+      def build_processors_uri(type, file_type, engine_extnames, pipeline)
+        engines = engine_extnames.join(',') if engine_extnames.any?
+        query = encode_uri_query_params(
+          type: type,
+          file_type: file_type,
+          engines: engines,
+          pipeline: pipeline
+        )
+        "processors:#{query}"
+      end
 
-      unregister_bundle_processor 'text/css', :css_compressor
-      return unless compressor
+      def processors_for(type, file_type, engine_extnames, pipeline)
+        pipeline ||= :default
+        config[:pipelines][pipeline.to_sym].call(self, type, file_type, engine_extnames)
+      end
 
-      register_bundle_processor 'text/css', :css_compressor do |context, data|
-        compressor.compress(data)
+      def default_processors_for(type, file_type, engine_extnames)
+        bundled_processors = config[:bundle_processors][type]
+        if bundled_processors.any?
+          bundled_processors
+        else
+          self_processors_for(type, file_type, engine_extnames)
+        end
       end
-    end
 
-    # Return JS compressor or nil if none is set
-    def js_compressor
-      bundle_processors('application/javascript').detect { |klass|
-        klass.respond_to?(:name) &&
-          klass.name == 'Sprockets::Processor (js_compressor)'
-      }
-    end
+      def self_processors_for(type, file_type, engine_extnames)
+        processors = []
 
-    # Assign a compressor to run on `application/javascript` assets.
-    #
-    # The compressor object must respond to `compress` or `compile`.
-    def js_compressor=(compressor)
-      expire_index!
+        processors.concat config[:postprocessors][type]
+
+        if type != file_type && processor = config[:transformers][file_type][type]
+          processors << processor
+        end
 
-      unregister_bundle_processor 'application/javascript', :js_compressor
-      return unless compressor
+        processors.concat engine_extnames.map { |ext| engines[ext] }
+        processors.concat config[:preprocessors][file_type]
+
+        if processors.any? || mime_type_charset_detecter(type)
+          processors << FileReader
+        end
 
-      register_bundle_processor 'application/javascript', :js_compressor do |context, data|
-        compressor.compress(data)
+        processors
       end
-    end
 
     private
-      def add_engine_to_trail(ext, klass)
-        @trail.append_extension(ext.to_s)
+      def register_config_processor(type, mime_type, klass, proc = nil, &block)
+        proc ||= block
+        processor = wrap_processor(klass, proc)
+
+        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
+
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.delete(klass)
+          processors
+        end
+
+        compute_transformers!
+      end
 
-        if klass.respond_to?(:default_mime_type) && klass.default_mime_type
-          if format_ext = extension_for_mime_type(klass.default_mime_type)
-            @trail.alias_extension(ext.to_s, format_ext)
+      def wrap_processor(klass, proc)
+        if !proc
+          if klass.respond_to?(:call)
+            klass
+          else
+            LegacyTiltProcessor.new(klass)
           end
+        elsif proc.respond_to?(:arity) && proc.arity == 2
+          LegacyProcProcessor.new(klass.to_s, proc)
+        else
+          proc
         end
       end
   end

data/lib/sprockets/processor_utils.rb

@@ -0,0 +1,103 @@
+module Sprockets
+  # Functional utilities for dealing with Processor functions.
+  #
+  # A Processor is a general function that my modify or transform an asset as
+  # part of the pipeline. CoffeeScript to JavaScript conversion, Minification
+  # or Concatenation are all implemented as seperate Processor steps.
+  #
+  # Processors maybe any object that responds to call. So procs or a class that
+  # defines a self.call method.
+  #
+  # For ergonomics, processors may return a number of shorthand values.
+  # Unfortunately, this means that processors can not compose via ordinary
+  # function composition. The composition helpers here can help.
+  module ProcessorUtils
+    extend self
+
+    # 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
+    end
+
+    # Public: Invoke list of processors in right to left order.
+    #
+    # The right to left order processing mirrors standard function composition.
+    # Think about:
+    #
+    #   bundle.call(uglify.call(coffee.call(input)))
+    #
+    # processors - Array of processor callables
+    # input - Hash of input data to pass to each processor
+    #
+    # Returns a Hash with :data and other processor metadata key/values.
+    def call_processors(processors, input)
+      data = input[:data] || ""
+      metadata = (input[:metadata] || {}).dup
+
+      processors.reverse_each do |processor|
+        result = call_processor(processor, input.merge(data: data, metadata: metadata))
+        data = result.delete(:data)
+        metadata.merge!(result)
+      end
+
+      metadata.merge(data: data)
+    end
+
+    # Public: Invoke processor.
+    #
+    # processor - Processor callables
+    # input - Hash of input data to pass to processor
+    #
+    # Returns a Hash with :data and other processor metadata key/values.
+    def call_processor(processor, input)
+      metadata = (input[:metadata] || {}).dup
+      metadata[:data] = input[:data]
+
+      case result = processor.call({data: "", metadata: {}}.merge(input))
+      when NilClass
+        metadata
+      when Hash
+        metadata.merge(result)
+      when String
+        metadata.merge(data: result)
+      else
+        raise TypeError, "invalid processor return type: #{result.class}"
+      end
+    end
+
+    # Internal: Get processor defined cached key.
+    #
+    # processor - Processor function
+    #
+    # Returns JSON serializable key or nil.
+    def processor_cache_key(processor)
+      processor.cache_key if processor.respond_to?(:cache_key)
+    end
+
+    # Internal: Get combined cache keys for set of processors.
+    #
+    # processors - Array of processor functions
+    #
+    # Returns Array of JSON serializable keys.
+    def processors_cache_keys(processors)
+      processors.map { |processor| processor_cache_key(processor) }
+    end
+  end
+end