Class: Braintrust::Vendor::Mustache::Template

Inherits:
Object
  • Object
show all
Defined in:
lib/braintrust/vendor/mustache/template.rb

Overview

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:

>> Braintrust::Vendor::Mustache.render(template, hash)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(source, options = {}) ⇒ Template

Expects a Mustache template as a string along with a template path, which it uses to find partials. Options may be passed.



31
32
33
34
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 31

def initialize(source, options = {})
  @source = source
  @options = options
end

Instance Attribute Details

#source ⇒ Object (readonly)

Returns the value of attribute source.



27
28
29
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 27

def source
  @source
end

Class Method Details

.recursor(toks, section, &block) ⇒ Object

Simple recursive iterator for tokens



123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 123

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

Instance Method Details

#compile(src = @source) ⇒ Object Also known as: to_s

Does the dirty work of transforming a Mustache template into an interpolation-friendly Ruby string.



58
59
60
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 58

def compile(src = @source)
  Generator.new(@options).compile(tokens(src))
end

#partials ⇒ Array

Returns an array of partials.

Partials that belong to sections are included, but the section name is not preserved

Returns:

  • (Array) —

    Returns an array of partials.



112
113
114
115
116
117
118
119
120
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 112

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

#render(context) ⇒ Object

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.



43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 43

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

#sections ⇒ Array

Returns an array of sections.

Sections that belong to other sections will be of the form ‘section1.childsection`

Returns:

  • (Array) —

    Returns an array of section.



95
96
97
98
99
100
101
102
103
104
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 95

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

#tags ⇒ Array

Returns an array of tags.

Tags that belong to sections will be of the form ‘section1.tag`.

Returns:

  • (Array) —

    Returns an array of tags.



77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 77

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

#tokens(src = @source) ⇒ Array

Returns an array of tokens for a given template.

Returns:

  • (Array) —

    Array of tokens.



67
68
69
 
# File 'lib/braintrust/vendor/mustache/template.rb', line 67

def tokens(src = @source)
  Parser.new(@options).compile(src)
end