Class: Braintrust::Vendor::Mustache::Parser

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

Overview

The Parser is responsible for taking a string template and converting it into an array of tokens and, really, expressions. It raises SyntaxError if there is anything it doesn’t understand and knows which sigil corresponds to which tag type.

For example, given this template:

Hi {{thing}}!

Run through the Parser we’ll get these tokens:

[:multi,
  [:static, "Hi "],
  [:mustache, :etag, "thing"],
  [:static, "!\n"]]

Defined Under Namespace

Classes: SyntaxError

Constant Summary collapse

VALID_TYPES =

The sigil types which are valid after an opening ‘{{`

["#", "^", "/", "=", "!", "<", ">", "&", "{"].map(&:freeze)
SKIP_WHITESPACE =

After these types of tags, all whitespace until the end of the line will be skipped if they are the first (and only) non-whitespace content on the line.

["#", "^", "/", "<", ">", "=", "!"].map(&:freeze)
ALLOWED_CONTENT =

The content allowed in a tag name.

/(\w|[?!\/.=-])*/
ANY_CONTENT =

These types of tags allow any content, the rest only allow ALLOWED_CONTENT.

["!", "="].map(&:freeze)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Parser

Accepts an options hash which does nothing but may be used in the future.



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

def initialize(options = {})
  @options = options
  @option_inline_partials_at_compile_time = options[:inline_partials_at_compile_time]
  if @option_inline_partials_at_compile_time
    @partial_resolver = options[:partial_resolver]
    raise ArgumentError.new "Missing or invalid partial_resolver" unless @partial_resolver.respond_to? :call
  end

  # Initialize default tags
  self.otag ||= "{{"
  self.ctag ||= "}}"
end

Instance Attribute Details

#ctag ⇒ Object

Returns the value of attribute ctag.



90
91
92
 
# File 'lib/braintrust/vendor/mustache/parser.rb', line 90

def ctag
  @ctag
end

#otag ⇒ Object

Returns the value of attribute otag.



90
91
92
 
# File 'lib/braintrust/vendor/mustache/parser.rb', line 90

def otag
  @otag
end

Class Method Details

.add_type(*types, &block) ⇒ Object

Add a supported sigil type (with optional aliases) to the Parser.

Requires a block, which will be sent the following parameters:

  • content - The raw content of the tag

  • fetch- A mustache context fetch expression for the content

  • padding - Indentation whitespace from the currently-parsed line

  • pre_match_position - Location of the scanner before a match was made

The provided block will be evaluated against the current instance of Parser, and may append to the Parser’s @result as needed.



68
69
70
71
72
73
74
75
76
 
# File 'lib/braintrust/vendor/mustache/parser.rb', line 68

def self.add_type(*types, &block)
  types = types.map(&:to_s)
  type, *aliases = types
  method_name = :"scan_tag_#{type}"
  define_method(method_name, &block)
  aliases.each { |a| alias_method :"scan_tag_#{a}", method_name }
  types.each { |t| VALID_TYPES << t unless VALID_TYPES.include?(t) }
  @valid_types = nil
end

.valid_types ⇒ Object 



53
54
55
 
# File 'lib/braintrust/vendor/mustache/parser.rb', line 53

def self.valid_types
  @valid_types ||= Regexp.new(VALID_TYPES.map { |t| Regexp.escape(t) }.join("|"))
end

Instance Method Details

#compile(template) ⇒ Object

Given a string template, returns an array of tokens.



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/braintrust/vendor/mustache/parser.rb', line 122

def compile(template)
  @encoding = nil

  if template.respond_to?(:encoding)
    @encoding = template.encoding
    template = template.dup.force_encoding("BINARY")
  end

  # Keeps information about opened sections.
  @sections = []
  @result = [:multi]
  @scanner = StringScanner.new(template)

  # Scan until the end of the template.
  until @scanner.eos?
    scan_tags || scan_text
  end

  unless @sections.empty?
    # We have parsed the whole file, but there's still opened sections.
    type, pos, _ = @sections.pop
    error "Unclosed section #{type.inspect}", pos
  end

  @result
end