class Temple::Engine


engine.call(something)
engine = MyEngine.new(:strict => “For MyParser”)
end
replace Temple::Generators::ArrayBuffer, Temple::Generators::RailsOutputBuffer
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 build_chain 

def build_chain
  chain.map do |e|
    name, filter, option_filter, local_options = e
    case filter
    when Class
      filtered_options = Hash[*option_filter.select {|k| options.include?(k) }.map {|k| [k, options[k]] }.flatten]
      filter.new(Utils::ImmutableHash.new(local_options, filtered_options))
    when UnboundMethod
      filter.bind(self)
    else
      filter
    end
  end
end

def call(input) 

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

def initialize(o = {}) 

def initialize(o = {})
  super
  @chain = self.class.chain.dup
  yield(self) if block_given?
  [*options[:chain]].compact.each {|block| block.call(self) }
  @chain = build_chain
end