class Temple::Engine

@api public
engine.call(something)
engine = MyEngine.new(strict: “For MyParser”)
end
replace :ArrayBuffer, Temple::Generators::RailsOutputBuffer
before :ArrayBuffer, Temple::Filters::Validator
append MyCodeOptimizer
class SpecialEngine < MyEngine
end
generator :ArrayBuffer, :buffer
# Finally the generator
filter :DynamicInliner
filter :StaticMerger
filter :MultiFlattener
# Then some general optimizations filters
use MyFilter
# Then a custom filter
use MyParser, :strict
# First run MyParser, passing the :strict option
class MyEngine < Temple::Engine
some filters and a generator).
An engine is simply a chain of compilers (that often includes a parser,

def self.chain 

def self.chain
  @chain ||= superclass.respond_to?(:chain) ? superclass.chain.dup : []
end

def call(input) 

def call(input)
  call_chain.inject(input) {|m, e| e.call(m) }
end

def call_chain 

def call_chain
  @call_chain ||= @chain.map do |name, constructor|
    f = constructor.call(self)
    raise "Constructor #{name} must return callable object" if f && !f.respond_to?(:call)
    f
  end.compact
end

def chain_modified! 

def chain_modified!
  @call_chain = nil
end

def initialize(opts = {}) 

def initialize(opts = {})
  super
  @chain = self.class.chain.dup
end