class Mustache::Template
A Template represents a Mustache template. It compiles and caches a raw string template into something usable.
The idea is this: when handed a Mustache template, convert it into a Ruby string by transforming Mustache tags into interpolated Ruby.
You shouldn't use this class directly, instead:
>> Mustache.render(template, hash)
Attributes
Public Class Methods
Expects a Mustache template as a string along with a template path, which it uses to find partials.
# File lib/mustache/template.rb, line 22 def initialize(source) @source = source end
Private Class Methods
Simple recursive iterator for tokens
# File lib/mustache/template.rb, line 117 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
Public Instance Methods
Does the dirty work of transforming a Mustache template into an interpolation-friendly Ruby string.
# File lib/mustache/template.rb, line 48 def compile(src = @source) Generator.new.compile(tokens(src)) end
Returns an array of partials.
Partials that belong to sections are included, but the section name is not preserved
@return [Array] Returns an array of partials.
# File lib/mustache/template.rb, line 102 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
Renders the `@source` Mustache template using the given `context`, which should be a simple hash keyed with symbols.
The first time a template is rendered, this method is overriden and from then on it is “compiled”. Subsequent calls will skip the compilation step and run the Ruby version of the template directly.
# File lib/mustache/template.rb, line 33 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
Returns an array of sections.
Sections that belong to other sections will be of the form `section1.childsection`
@return [Array] Returns an array of section.
# File lib/mustache/template.rb, line 85 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
Returns an array of tokens for a given template.
@return [Array] Array of tokens.
# File lib/mustache/template.rb, line 57 def tokens(src = @source) Parser.new.compile(src) end