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, *args, &blk)

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

def self.filters 

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

def self.generator(compiler, *args, &blk)

Shortcut for use Temple::Generator::parser 
def self.generator(compiler, *args, &blk)
  use(Temple::Core.const_get(compiler), *args, &blk)
end

def self.parser(parser, *args, &blk)

Shortcut for use Temple::Parsers::parser 
def self.parser(parser, *args, &blk)
  use(Temple::Parsers.const_get(parser), *args, &blk)
end

def self.use(filter, *args, &blk) 

def self.use(filter, *args, &blk)
  filters << [filter, args, blk]
end

def compile(thing) 

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

def initialize(options = {}) 

def initialize(options = {})
  @chain = self.class.filters.map do |filter, args, blk|
    opt = args.last.is_a?(Hash) ? args.last : {}
    opt = args.inject(opt) do |memo, ele|
      memo[ele] = options[ele] if options.has_key?(ele)
      memo
    end
    
    filter.new(opt, &blk)
  end
end