Module: Condenser::Pipeline

Included in:
Condenser
Defined in:
lib/condenser/pipeline.rb

Constant Summary collapse

CONFIG_VARS = 
%w(mime_types extensions templates preprocessors transformers postprocessors minifiers exporters writers).map(&:to_sym)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.prepended(base) ⇒ Object 



6
7
8
9
10
11
12
13
 
# File 'lib/condenser/pipeline.rb', line 6

def self.prepended(base)
  base.extend(self)
  CONFIG_VARS.each do |var|
    base.instance_variable_set("@#{var}", {})
    base.send(:attr_reader, var)
    self.send(:attr_reader, var)
  end
end

Instance Method Details

#clear_pipeline ⇒ Object 



109
110
111
 
# File 'lib/condenser/pipeline.rb', line 109

def clear_pipeline
  (CONFIG_VARS - [:mime_types, :extensions]).each { |v| self.instance_variable_set("@#{v}", {}) }
end

#initialize(*args) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/condenser/pipeline.rb', line 15

def initialize(*args)
  CONFIG_VARS.each do |var_name|
    original_var = self.class.instance_variable_get("@#{var_name}")
    new_var = original_var.dup
    
    if original_var.is_a?(Hash)
      original_var.each do |k, v|
        new_var[k] = v.dup if v.is_a?(Hash) || v.is_a?(Array)
      end
    end

    instance_variable_set("@#{var_name}", new_var)
  end
  super
end

#minifier_for(mime_type) ⇒ Object 



77
78
79
 
# File 'lib/condenser/pipeline.rb', line 77

def minifier_for(mime_type)
  @minifiers[mime_type]
end

#register_exporter(mime_type, engine) ⇒ Object 



65
66
67
 
# File 'lib/condenser/pipeline.rb', line 65

def register_exporter(mime_type, engine)
  @exporters[mime_type] = engine
end

#register_mime_type(mime_type, extensions: nil, extension: nil, charset: :default) ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/condenser/pipeline.rb', line 31

def register_mime_type(mime_type, extensions: nil, extension: nil, charset: :default)
  extensions = Array(extensions || extension)

  @mime_types[mime_type] = { extensions: extensions, charset: charset }
  extensions.each { |ext| @extensions[ext] = mime_type }
end

#register_minifier(mime_type, engine) ⇒ Object 



73
74
75
 
# File 'lib/condenser/pipeline.rb', line 73

def register_minifier(mime_type, engine)
  @minifiers[mime_type] = engine
end

#register_postprocessor(mime_type, engine) ⇒ Object 



60
61
62
63
 
# File 'lib/condenser/pipeline.rb', line 60

def register_postprocessor(mime_type, engine)
  @postprocessors[mime_type] ||= []
  @postprocessors[mime_type] << engine
end

#register_preprocessor(mime_type, engine) ⇒ Object 



42
43
44
45
 
# File 'lib/condenser/pipeline.rb', line 42

def register_preprocessor(mime_type, engine)
  @preprocessors[mime_type] ||= []
  @preprocessors[mime_type] << engine
end

#register_template(mime_type, engine) ⇒ Object 



38
39
40
 
# File 'lib/condenser/pipeline.rb', line 38

def register_template(mime_type, engine)
  @templates[mime_type] = engine
end

#register_transformer(from_mime_type, to_mime_type, engine) ⇒ Object 



55
56
57
58
 
# File 'lib/condenser/pipeline.rb', line 55

def register_transformer(from_mime_type, to_mime_type, engine)
  @transformers[from_mime_type] ||= {}
  @transformers[from_mime_type][to_mime_type] = engine
end

#register_writer(engine) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/condenser/pipeline.rb', line 85

def register_writer(engine)
  Array(engine.mime_types).each do |mime_type|
    @writers[mime_type] ||= []
    @writers[mime_type] << engine
  end
end

#unregister_exporter(mime_type, engine) ⇒ Object 



69
70
71
 
# File 'lib/condenser/pipeline.rb', line 69

def unregister_exporter(mime_type, engine)
  @exporters[mime_type] = nil
end

#unregister_minifier(mime_type) ⇒ Object 



81
82
83
 
# File 'lib/condenser/pipeline.rb', line 81

def unregister_minifier(mime_type)
  @minifiers[mime_type] = nil
end

#unregister_preprocessor(mime_type, engine = nil) ⇒ Object 



47
48
49
50
51
52
53
 
# File 'lib/condenser/pipeline.rb', line 47

def unregister_preprocessor(mime_type, engine=nil)
  if engine.nil?
    @preprocessors[mime_type].clear
  else
    @preprocessors[mime_type]&.delete(engine)
  end
end

#unregister_writer(mime_types, engine, added_mime_types = nil) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/condenser/pipeline.rb', line 92

def unregister_writer(mime_types, engine, added_mime_types=nil)
  mime_types = @writers.keys if mime_types.nil?
  Array(mime_types).each do |mime_type|
    @writers[mime_type].select! do |writer|
      if engine.nil? || engine == writer[0] || writer[0].is_a?(engine)
        if added_mime_types.nil? || added_mime_types == writer[1]
          false
        else
          true
        end
      else
        true
      end
    end
  end
end