module Sprockets::ProcessorUtils

def autoload_processor(mod, filename)

Returns AutoloadProcessor.

filename - String require path for module
mod - Symbol name of processor class/module

Sprockets.autoload_processor :CoffeeScriptProcessor, 'sprockets/coffee_script_processor'

Internal: Setup autoload and wrapper for lazy loaded processor. 
def autoload_processor(mod, filename)
  autoload(mod, filename)
  AutoloadProcessor.new(self, mod)
end

def call_processors(processors, input)

Returns a Hash with :data and other processor metadata key/values.

input - Hash of input data to pass to each processor
processors - Array of processor callables

bundle.call(uglify.call(coffee.call(input)))

Think about:
The right to left order processing mirrors standard function composition.

Public: Invoke list of processors in right to left order. 
def call_processors(processors, input)
  data = input[:data] || ""
  metadata = input[:metadata] || {}
  processors.reverse_each do |processor|
    result = processor.call(input.merge(data: data, metadata: metadata))
    case result
    when NilClass
    when Hash
      data = result.delete(:data) if result.key?(:data)
      metadata.merge!(result)
    when String
      data = result
    else
      raise TypeError, "invalid processor return type: #{result.class}"
    end
  end
  metadata.merge(data: data)
end

def compose_processors(*processors)

Returns a composed Proc.

processors - Array of processors callables

Public: Compose processors in right to left order. 
def compose_processors(*processors)
  context = self
  obj = method(:call_processors).to_proc.curry[processors]
  metaclass = (class << obj; self; end)
  metaclass.send(:define_method, :cache_key) do
    context.processors_cache_keys(processors)
  end
  obj
end

def processor_cache_key(processor)

Returns JSON serializable key or nil.

processor - Processor function

Internal: Get processor defined cached key. 
def processor_cache_key(processor)
  processor.cache_key if processor.respond_to?(:cache_key)
end

def processors_cache_keys(processors)

Returns Array of JSON serializable keys.

processors - Array of processor functions

Internal: Get combined cache keys for set of processors. 
def processors_cache_keys(processors)
  processors.map { |processor| processor_cache_key(processor) }
end