class Temple::Engine

An engine is simply a chain of compilers (that often includes a parser, some filters and a generator).

class MyEngine < Temple::Engine
  # First run MyParser, passing the :strict option
  use MyParser, :strict

  # Then a custom filter
  use MyFilter

  # Then some general optimizations filters
  filter :MultiFlattener
  filter :StaticMerger
  filter :DynamicInliner

  # Finally the generator
  generator :ArrayBuffer, :buffer
end

class SpecialEngine < MyEngine
  append MyCodeOptimizer
  before :ArrayBuffer, Temple::Filters::Validator
  replace :ArrayBuffer, Temple::Generators::RailsOutputBuffer
end

engine = MyEngine.new(:strict => "For MyParser")
engine.call(something)

@api public

Attributes

chain[R]

Public Class Methods

chain() click to toggle source
# File lib/temple/engine.rb, line 40
def self.chain
  @chain ||= superclass.respond_to?(:chain) ? superclass.chain.dup : []
end
new(opts = {}) click to toggle source
Calls superclass method Temple::Mixins::Options.new
# File lib/temple/engine.rb, line 44
def initialize(opts = {})
  super
  @chain = self.class.chain.dup
end

Public Instance Methods

call(input) click to toggle source
# File lib/temple/engine.rb, line 49
def call(input)
  call_chain.inject(input) {|m, e| e.call(m) }
end

Protected Instance Methods

call_chain() click to toggle source
# File lib/temple/engine.rb, line 59
def call_chain
  @call_chain ||= @chain.map {|name, constructor| constructor.call(self) }.compact
end
chain_modified!() click to toggle source
# File lib/temple/engine.rb, line 55
def chain_modified!
  @call_chain = nil
end