Module: Sprockets::Transformers

Includes:
HTTPUtils, ProcessorUtils, Utils
Included in:
Configuration, Loader
Defined in:
lib/sprockets/transformers.rb

Defined Under Namespace

Classes: Transformer

Constant Summary

Constants included from ProcessorUtils

ProcessorUtils::VALID_METADATA_COMPOUND_TYPES, ProcessorUtils::VALID_METADATA_COMPOUND_TYPES_HASH, ProcessorUtils::VALID_METADATA_TYPES, ProcessorUtils::VALID_METADATA_VALUE_TYPES, ProcessorUtils::VALID_METADATA_VALUE_TYPES_HASH

Instance Method Summary collapse

Methods included from HTTPUtils

#find_best_mime_type_match, #find_best_q_match, #find_mime_type_matches, #find_q_matches, #match_mime_type?, #match_mime_type_keys, #parse_q_values

Methods included from ProcessorUtils

#call_processor, #call_processors, #compose_processors, #processor_cache_key, #processors_cache_keys, #valid_processor_metadata_value?, #validate_processor_result!

Methods included from Utils

#concat_javascript_sources, #dfs, #dfs_paths, #duplicable?, #hash_reassoc, #hash_reassoc1, #module_include, #string_end_with_semicolon?

Instance Method Details

#compose_transformers(transformers, types, preprocessors, postprocessors) ⇒ Object

Internal: Compose multiple transformer steps into a single processor function.

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

Returns Processor.


115
116
117
118
119
120
121
122
123
124
125
126
127
128
# File 'lib/sprockets/transformers.rb', line 115

def compose_transformers(transformers, types, preprocessors, postprocessors)
  if types.length < 2
    raise ArgumentError, "too few transform types: #{types.inspect}"
  end

  processors = types.each_cons(2).map { |src, dst|
    unless processor = transformers[src][dst]
      raise ArgumentError, "missing transformer for type: #{src} to #{dst}"
    end
    processor
  }

  compose_transformer_list processors, preprocessors, postprocessors
end

#expand_transform_accepts(parsed_accepts) ⇒ Object

Internal: Expand accept type list to include possible transformed types.

parsed_accepts - Array of accept q values

Examples

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

Returns an expanded Array of q values.


97
98
99
100
101
102
103
104
105
106
# File 'lib/sprockets/transformers.rb', line 97

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

#register_transformer(from, to, proc) ⇒ Object

Public: Register a transformer from and to a mime type.

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

Examples

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

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

Returns nothing.


38
39
40
41
42
43
# File 'lib/sprockets/transformers.rb', line 38

def register_transformer(from, to, proc)
  self.config = hash_reassoc(config, :registered_transformers) do |transformers|
    transformers << Transformer.new(from, to, proc)
  end
  compute_transformers!(self.config[:registered_transformers])
end

#register_transformer_suffix(types, type_format, extname, processor) ⇒ Object

Internal: Register transformer for existing type adding a suffix.

types - Array of existing mime type Strings type_format - String suffix formatting string extname - String extension to append processor - Callable block that accepts an input Hash.

Returns nothing.


53
54
55
56
57
58
59
60
61
62
63
# File 'lib/sprockets/transformers.rb', line 53

def register_transformer_suffix(types, type_format, extname, processor)
  Array(types).each do |type|
    extensions, charset = mime_types[type].values_at(:extensions, :charset)
    parts = type.split('/')
    suffix_type = type_format.sub('\1', parts[0]).sub('\2', parts[1])
    extensions = extensions.map { |ext| "#{ext}#{extname}" }

    register_mime_type(suffix_type, extensions: extensions, charset: charset)
    register_transformer(suffix_type, type, processor)
  end
end

#resolve_transform_type(type, accept) ⇒ Object

Internal: Resolve target mime type that the source type should be transformed to.

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

Examples

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

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

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

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


83
84
85
# File 'lib/sprockets/transformers.rb', line 83

def resolve_transform_type(type, accept)
  find_best_mime_type_match(accept || '*/*', [type].compact + config[:transformers][type].keys)
end

#transformersObject

Public: Two level mapping of a source mime type to a target mime type.

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

18
19
20
# File 'lib/sprockets/transformers.rb', line 18

def transformers
  config[:transformers]
end