Module: Sprockets::ProcessorUtils

Relationships & Source Files
Namespace Children
Classes: `CompositeProcessor`
Extension / Inclusion / Inheritance Descendants
Extended In: `::Sprockets`
Included In: `Base`, `CachedEnvironment`, `Configuration`, `Environment`, `Loader`, `Processing`, `Transformers`
Defined in:	lib/sprockets/processor_utils.rb

Overview

Functional utilities for dealing with Processor functions.

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 separate 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.

Constant Summary

VALID_METADATA_COMPOUND_TYPES =

Internal: Set of all nested compound metadata types that can nest values.

# File 'lib/sprockets/processor_utils.rb', line 126
```
Set.new([
  Array,
  Hash,
  Set
]).freeze
```
VALID_METADATA_COMPOUND_TYPES_HASH =

Internal: Hash of all nested compound metadata types that can nest values.

# File 'lib/sprockets/processor_utils.rb', line 139
```
VALID_METADATA_COMPOUND_TYPES.each_with_object({}) do |type, hash|
  hash[type] = true
end.freeze
```
VALID_METADATA_TYPES =

Internal: Set of all allowed metadata types.

# File 'lib/sprockets/processor_utils.rb', line 144
```
(VALID_METADATA_VALUE_TYPES + VALID_METADATA_COMPOUND_TYPES).freeze
```
VALID_METADATA_VALUE_TYPES =

Internal: Set of all “simple” value types allowed to be returned in processor metadata.

# File 'lib/sprockets/processor_utils.rb', line 116
```
Set.new([
  String,
  Symbol,
  TrueClass,
  FalseClass,
  NilClass,
  Integer
]).freeze
```
VALID_METADATA_VALUE_TYPES_HASH =

Internal: Hash of all “simple” value types allowed to be returned in processor metadata.

# File 'lib/sprockets/processor_utils.rb', line 134
```
VALID_METADATA_VALUE_TYPES.each_with_object({}) do |type, hash|
  hash[type] = true
end.freeze
```

Instance Method Summary

#call_processor(processor, input)

Public: Invoke processor.
#call_processors(processors, input)

Public: Invoke list of processors in right to left order.
#compose_processors(*processors)

Public: Compose processors in right to left order.
#processor_cache_key(processor)

Internal: Get processor defined cached key.
#processors_cache_keys(processors)

Internal: Get combined cache keys for set of processors.
#validate_processor_result!(result)

Internal: Validate returned result of calling a processor pipeline and raise a friendly user error message.

Instance Method Details

#call_processor(processor, input)

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.

[ GitHub ]

# File 'lib/sprockets/processor_utils.rb', line 80


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

#call_processors(processors, input)

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.

[ GitHub ]

# File 'lib/sprockets/processor_utils.rb', line 61


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

#compose_processors(*processors)

Public: Compose processors in right to left order.

processors - Array of processors callables

Returns a composed Proc.

[ GitHub ]

# File 'lib/sprockets/processor_utils.rb', line 46


def compose_processors(*processors)
  CompositeProcessor.create processors
end

#processor_cache_key(processor)

Internal: Get processor defined cached key.

processor - Processor function

Returns JSON serializable key or nil.

[ GitHub ]

# File 'lib/sprockets/processor_utils.rb', line 101


def processor_cache_key(processor)
  processor.cache_key if processor.respond_to?(:cache_key)
end

#processors_cache_keys(processors)

Internal: Get combined cache keys for set of processors.

processors - Array of processor functions

Returns Array of JSON serializable keys.

[ GitHub ]

# File 'lib/sprockets/processor_utils.rb', line 110


def processors_cache_keys(processors)
  processors.map { |processor| processor_cache_key(processor) }
end

#validate_processor_result!(result)

Internal: Validate returned result of calling a processor pipeline and raise a friendly user error message.

result - Metadata Hash returned from call_processors

Returns result or raises a TypeError.

[ GitHub ]

# File 'lib/sprockets/processor_utils.rb', line 152


def validate_processor_result!(result)
  if !result.instance_of?(Hash)
    raise TypeError, "processor metadata result was expected to be a Hash, but was #{result.class}"
  end

  if !result[:data].instance_of?(String)
    raise TypeError, "processor :data was expected to be a String, but as #{result[:data].class}"
  end

  result.each do |key, value|
    if !key.instance_of?(Symbol)
      raise TypeError, "processor metadata[#{key.inspect}] expected to be a Symbol"
    end
  end

  result
end