Module: Sprockets::Processing

Includes:
Engines, Mime
Included in:
Base
Defined in:
lib/sprockets/processing.rb

Overview

‘Processing` is an internal mixin whose public methods are exposed on the `Environment` and `Index` classes.

Instance Method Summary collapse

Methods included from Engines

#engine_extensions, #engines

Methods included from Mime

#extension_for_mime_type, #mime_types

Instance Method Details

#bundle_processors(mime_type = nil) ⇒ Object

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



176
177
178
179
180
181
182
 
# File 'lib/sprockets/processing.rb', line 176

def bundle_processors(mime_type = nil)
  if mime_type
    @bundle_processors[mime_type].dup
  else
    deep_copy_hash(@bundle_processors)
  end
end

#css_compressor ⇒ Object

Return CSS compressor or nil if none is set



226
227
228
229
230
231
 
# File 'lib/sprockets/processing.rb', line 226

def css_compressor
  bundle_processors('text/css').detect { |klass|
    klass.respond_to?(:name) &&
      klass.name == 'Sprockets::Processor (css_compressor)'
  }
end

#css_compressor=(compressor) ⇒ Object

Assign a compressor to run on ‘text/css` assets.

The compressor object must respond to ‘compress` or `compile`.



236
237
238
239
240
241
242
243
244
245
 
# File 'lib/sprockets/processing.rb', line 236

def css_compressor=(compressor)
  expire_index!

  unregister_bundle_processor 'text/css', :css_compressor
  return unless compressor

  register_bundle_processor 'text/css', :css_compressor do |context, data|
    compressor.compress(data)
  end
end

#format_extensions ⇒ Object

Returns an ‘Array` of format extension `String`s.

format_extensions
# => ['.js', '.css']



25
26
27
 
# File 'lib/sprockets/processing.rb', line 25

def format_extensions
  @trail.extensions - @engines.keys
end

#js_compressor ⇒ Object

Return JS compressor or nil if none is set



248
249
250
251
252
253
 
# File 'lib/sprockets/processing.rb', line 248

def js_compressor
  bundle_processors('application/javascript').detect { |klass|
    klass.respond_to?(:name) &&
      klass.name == 'Sprockets::Processor (js_compressor)'
  }
end

#js_compressor=(compressor) ⇒ Object

Assign a compressor to run on ‘application/javascript` assets.

The compressor object must respond to ‘compress` or `compile`.



258
259
260
261
262
263
264
265
266
267
 
# File 'lib/sprockets/processing.rb', line 258

def js_compressor=(compressor)
  expire_index!

  unregister_bundle_processor 'application/javascript', :js_compressor
  return unless compressor

  register_bundle_processor 'application/javascript', :js_compressor do |context, data|
    compressor.compress(data)
  end
end

#postprocessors(mime_type = nil) ⇒ Object

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



67
68
69
70
71
72
73
 
# File 'lib/sprockets/processing.rb', line 67

def postprocessors(mime_type = nil)
  if mime_type
    @postprocessors[mime_type].dup
  else
    deep_copy_hash(@postprocessors)
  end
end

#preprocessors(mime_type = nil) ⇒ Object

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



51
52
53
54
55
56
57
 
# File 'lib/sprockets/processing.rb', line 51

def preprocessors(mime_type = nil)
  if mime_type
    @preprocessors[mime_type].dup
  else
    deep_copy_hash(@preprocessors)
  end
end

#processors(*args) ⇒ Object

Deprecated alias for ‘preprocessors`.



38
39
40
 
# File 'lib/sprockets/processing.rb', line 38

def processors(*args)
  preprocessors(*args)
end

#register_bundle_processor(mime_type, klass, &block) ⇒ Object

Registers a new Bundle Processor ‘klass` for `mime_type`.

register_bundle_processor  'text/css', Sprockets::CharsetNormalizer

A block can be passed for to create a shorthand processor.

register_bundle_processor :my_processor do |context, data|
  data.gsub(...)
end



194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/sprockets/processing.rb', line 194

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)
end

#register_engine(ext, klass) ⇒ Object

Registers a new Engine ‘klass` for `ext`.



30
31
32
33
34
35
 
# File 'lib/sprockets/processing.rb', line 30

def register_engine(ext, klass)
  # Overrides the global behavior to expire the index
  expire_index!
  add_engine_to_trail(ext, klass)
  super
end

#register_mime_type(mime_type, ext) ⇒ Object

Register a new mime type.



13
14
15
16
17
18
 
# File 'lib/sprockets/processing.rb', line 13

def register_mime_type(mime_type, ext)
  # Overrides the global behavior to expire the index
  expire_index!
  @trail.append_extension(ext)
  super
end

#register_postprocessor(mime_type, klass, &block) ⇒ Object

Registers a new Postprocessor ‘klass` for `mime_type`.

register_postprocessor 'text/css', Sprockets::CharsetNormalizer

A block can be passed for to create a shorthand processor.

register_postprocessor :my_processor do |context, data|
  data.gsub(...)
end



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

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

#register_preprocessor(mime_type, klass, &block) ⇒ Object

Registers a new Preprocessor ‘klass` for `mime_type`.

register_preprocessor 'text/css', Sprockets::DirectiveProcessor

A block can be passed for to create a shorthand processor.

register_preprocessor :my_processor do |context, data|
  data.gsub(...)
end



90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/sprockets/processing.rb', line 90

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)
end

#register_processor(*args, &block) ⇒ Object

Deprecated alias for ‘register_preprocessor`.



76
77
78
 
# File 'lib/sprockets/processing.rb', line 76

def register_processor(*args, &block)
  register_preprocessor(*args, &block)
end

#unregister_bundle_processor(mime_type, klass) ⇒ Object

Remove Bundle Processor ‘klass` for `mime_type`.

unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer



212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/sprockets/processing.rb', line 212

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})"
    }
  end

  @bundle_processors[mime_type].delete(klass)
end

#unregister_postprocessor(mime_type, klass) ⇒ Object

Remove Postprocessor ‘klass` for `mime_type`.

unregister_postprocessor 'text/css', Sprockets::DirectiveProcessor



154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/sprockets/processing.rb', line 154

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)
end

#unregister_preprocessor(mime_type, klass) ⇒ Object

Remove Preprocessor ‘klass` for `mime_type`.

unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor



137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/sprockets/processing.rb', line 137

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)
end

#unregister_processor(*args) ⇒ Object

Deprecated alias for ‘unregister_preprocessor`.



129
130
131
 
# File 'lib/sprockets/processing.rb', line 129

def unregister_processor(*args)
  unregister_preprocessor(*args)
end