class Mustache::Template

>> Mustache.render(template, hash)
You shouldn’t use this class directly, instead:
Ruby.
a Ruby string by transforming Mustache tags into interpolated
The idea is this: when handed a Mustache template, convert it into
a raw string template into something usable.
A Template represents a Mustache template. It compiles and caches

def self.recursor(toks, section, &block)

Simple recursive iterator for tokens 
def self.recursor(toks, section, &block)
  toks.map do |token|
    next unless token.is_a? Array
    if token.first == :mustache
      new_token, new_section, result, stop = yield(token, section)
      [ result ] + ( stop ? [] : recursor(new_token, new_section, &block))
    else
      recursor(token, section, &block)
    end
  end
end

def compile(src = @source)

interpolation-friendly Ruby string.
Does the dirty work of transforming a Mustache template into an 
def compile(src = @source)
  Generator.new(@options).compile(tokens(src))
end

def initialize(source, options = {})

path, which it uses to find partials. Options may be passed.
Expects a Mustache template as a string along with a template 
def initialize(source, options = {})
  @source = source
  @options = options
end

def partials

Returns:
  • (Array) - Returns an array of partials. 
def partials
  Template.recursor(tokens, []) do |token, section|
    if token[1] == :partial
      [ new_token=token, new_section=section, result=token[2], stop=true ]
    else
      [ new_token=token, new_section=section, result=nil, stop=false ]
    end
  end.flatten.reject(&:nil?).uniq
end

def render(context)

directly.
the compilation step and run the Ruby version of the template
and from then on it is "compiled". Subsequent calls will skip
The first time a template is rendered, this method is overriden

`context`, which should be a simple hash keyed with symbols.
Renders the `@source` Mustache template using the given 
def render(context)
  # Compile our Mustache template into a Ruby string
  compiled = "def render(ctx) #{compile} end"
  # Here we rewrite ourself with the interpolated Ruby version of
  # our Mustache template so subsequent calls are very fast and
  # can skip the compilation stage.
  instance_eval(compiled, __FILE__, __LINE__ - 1)
  # Call the newly rewritten version of #render
  render(context)
end

def sections

Returns:
  • (Array) - Returns an array of section. 
def sections
  Template.recursor(tokens, []) do |token, section|
    if [:section, :inverted_section].include?(token[1])
      new_section=(section + [token[2][2][0]])
      [ new_token=token[4], new_section, result=new_section.join('.'), stop=false ]
    else
      [ new_token=token, new_section=section, result=nil, stop=false ]
    end
  end.flatten.reject(&:nil?).uniq
end

def tags

Returns:
  • (Array) - Returns an array of tags. 
def tags
  Template.recursor(tokens, []) do |token, section|
    if [:etag, :utag].include?(token[1])
      [ new_token=nil, new_section=nil, result=((section + [token[2][2][0]]).join('.')), stop=true ]
    elsif [:section, :inverted_section].include?(token[1])
      [ new_token=token[4], new_section=(section + [token[2][2][0]]), result=nil, stop=false ]
    else
      [ new_token=token, new_section=section, result=nil, stop=false ]
    end
  end.flatten.reject(&:nil?).uniq
end

def tokens(src = @source)

Returns:
  • (Array) - Array of tokens. 
def tokens(src = @source)
  Parser.new(@options).compile(src)
end