class Temple::Engine


engine.compile(something)
engine = MyEngine.new(:strict => “For MyParser”)
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.filter(filter, *options, &block)

Shortcut for use Temple::Filters::parser 
def self.filter(filter, *options, &block)
  use(Temple::Filters.const_get(filter), *options, &block)
end

def self.filters 

def self.filters
  @filters ||= []
end

def self.generator(compiler, *options, &block)

Shortcut for use Temple::Generators::parser 
def self.generator(compiler, *options, &block)
  use(Temple::Generators.const_get(compiler), *options, &block)
end

def self.use(filter, *options, &block) 

def self.use(filter, *options, &block)
  filters << [filter, options, block]
end

def compile(thing) 

def compile(thing)
  @chain.inject(thing) { |m, e| e.compile(m) }
end

def initialize(opts = {}) 

def initialize(opts = {})
  super
  @chain = self.class.filters.map do |filter, opt, block|
    result = {}
    opt.each do |key|
      result[key] = options[key] if options.has_key?(key)
    end
    filter.new(result, &block)
  end
end