module Sprockets::Transformers

def compose_transformers(transformers, types)

Returns Processor.

types - Array of mime type steps
transformers - Two level Hash of a source mime type to a target mime type

function.
Internal: Compose multiple transformer steps into a single processor 
def compose_transformers(transformers, types)
  if types.length < 2
    raise ArgumentError, "too few transform types: #{types.inspect}"
  end
  i = 0
  processors = []
  loop do
    src = types[i]
    dst = types[i+1]
    break unless src && dst
    unless processor = transformers[src][dst]
      raise ArgumentError, "missing transformer for type: #{src} to #{dst}"
    end
    processors.concat config[:postprocessors][src]
    processors << processor
    processors.concat config[:preprocessors][dst]
    i += 1
  end
  if processors.size > 1
    compose_processors(*processors.reverse)
  elsif processors.size == 1
    processors.first
  end
end

def compute_transformers! 

def compute_transformers!
  registered_transformers = self.config[:registered_transformers]
  transformers = Hash.new { {} }
  inverted_transformers = Hash.new { Set.new }
  registered_transformers.keys.flat_map do |key|
    dfs_paths([key]) { |k| registered_transformers[k].keys }
  end.each do |types|
    src, dst = types.first, types.last
    processor = compose_transformers(registered_transformers, types)
    transformers[src] = {} unless transformers.key?(src)
    transformers[src][dst] = processor
    inverted_transformers[dst] = Set.new unless inverted_transformers.key?(dst)
    inverted_transformers[dst] << src
  end
  self.config = hash_reassoc(config, :transformers) { transformers }
  self.config = hash_reassoc(config, :inverted_transformers) { inverted_transformers }
end

def expand_transform_accepts(parsed_accepts)

Returns an expanded Array of q values.

# => [['application/javascript', 1.0], ['text/coffeescript', 0.8]]
expand_transform_accepts([['application/javascript', 1.0]])

Examples

parsed_accepts - Array of accept q values

Internal: Expand accept type list to include possible transformed types. 
def expand_transform_accepts(parsed_accepts)
  accepts = []
  parsed_accepts.each do |(type, q)|
    accepts.push([type, q])
    config[:inverted_transformers][type].each do |subtype|
      accepts.push([subtype, q * 0.8])
    end
  end
  accepts
end

def register_transformer(from, to, proc)

Returns nothing.

register_transformer 'image/svg+xml', 'image/png', ConvertSvgToPng

ConvertCoffeeScriptToJavaScript
register_transformer 'text/coffeescript', 'application/javascript',

Examples

proc - Callable block that accepts an input Hash.
to - String mime type
from - String mime type

Public: Register a transformer from and to a mime type. 
def register_transformer(from, to, proc)
  self.config = hash_reassoc(config, :registered_transformers, from) do |transformers|
    transformers.merge(to => proc)
  end
  compute_transformers!
end

def resolve_transform_type(type, accept)

Returns String mime type or nil is no type satisfied the accept value.

# => nil
resolve_transform_type('text/css', 'image/png')

# => 'image/png'
resolve_transform_type('image/svg+xml', 'image/png, image/*')

# => 'text/plain'
resolve_transform_type('text/plain', 'text/plain')

Examples

accept - String accept type list (default: '*/*')
type - String from mime type

transformed to.
Internal: Resolve target mime type that the source type should be 
def resolve_transform_type(type, accept)
  find_best_mime_type_match(accept || '*/*', [type].compact + config[:transformers][type].keys)
end

def transformers


}
}
'application/javascript' => ConvertCoffeeScriptToJavaScript
# => { 'text/coffeescript' => {
environment.transformers

Public: Two level mapping of a source mime type to a target mime type. 
def transformers
  config[:transformers]
end