Class: Mustache::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/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"]]

You can see the array of tokens for any template with the mustache(1) command line tool:

$ mustache --tokens test.mustache
[:multi, [:static, "Hi "], [:mustache, :etag, "thing"], [:static, "!\n"]]

Defined Under Namespace

Classes: SyntaxError

Constant Summary collapse

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.

[ '#', '^', '/', '<', '>', '=', '!' ]
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.

[ '!', '=' ]

Instance Attribute 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.



64
65
66
 
# File 'lib/mustache/parser.rb', line 64

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

Instance Attribute Details

#ctag ⇒ Object

The closing tag delimiter. This too may be changed at runtime.



74
75
76
 
# File 'lib/mustache/parser.rb', line 74

def ctag
  @ctag ||= '}}'
end

#otag ⇒ Object

The opening tag delimiter. This may be changed at runtime.



69
70
71
 
# File 'lib/mustache/parser.rb', line 69

def otag
  @otag ||= '{{'
end

#result ⇒ Object (readonly)

Returns the value of attribute result.



59
60
61
 
# File 'lib/mustache/parser.rb', line 59

def result
  @result
end

#scanner ⇒ Object (readonly)

Returns the value of attribute scanner.



59
60
61
 
# File 'lib/mustache/parser.rb', line 59

def scanner
  @scanner
end

Instance Method Details

#compile(template) ⇒ Object

Given a string template, returns an array of tokens.



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/mustache/parser.rb', line 79

def compile(template)
  if template.respond_to?(:encoding)
    @encoding = template.encoding
    template = template.dup.force_encoding("BINARY")
  else
    @encoding = nil
  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

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

  @result
end

#error(message, pos = position) ⇒ Object

Raises a SyntaxError. The message should be the name of the error - other details such as line number and position are handled for you.

Raises:



259
260
261
 
# File 'lib/mustache/parser.rb', line 259

def error(message, pos = position)
  raise SyntaxError.new(message, pos)
end

#position ⇒ Object

Returns [lineno, column, line]



238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/mustache/parser.rb', line 238

def position
  # The rest of the current line
  rest = @scanner.check_until(/\n|\Z/).to_s.chomp

  # What we have parsed so far
  parsed = @scanner.string[0...@scanner.pos]

  lines = parsed.split("\n")

  [ lines.size, lines.last.size - 1, lines.last + rest ]
end

#regexp(thing) ⇒ Object

Used to quickly convert a string into a regular expression usable by the string scanner.



252
253
254
 
# File 'lib/mustache/parser.rb', line 252

def regexp(thing)
  /#{Regexp.escape(thing)}/
end

#scan_tags ⇒ Object

Find {mustaches} and add them to the @result array.



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/mustache/parser.rb', line 107

def scan_tags
  # Scan until we hit an opening delimiter.
  start_of_line = @scanner.beginning_of_line?
  pre_match_position = @scanner.pos
  last_index = @result.length

  return unless x = @scanner.scan(/([ \t]*)?#{Regexp.escape(otag)}/)
  padding = @scanner[1] || ''

  # Don't touch the preceding whitespace unless we're matching the start
  # of a new line.
  unless start_of_line
    @result << [:static, padding] unless padding.empty?
    pre_match_position += padding.length
    padding = ''
  end

  # Since {{= rewrites ctag, we store the ctag which should be used
  # when parsing this specific tag.
  current_ctag = self.ctag
  type = @scanner.scan(/#|\^|\/|=|!|<|>|&|\{/)
  @scanner.skip(/\s*/)

  # ANY_CONTENT tags allow any character inside of them, while
  # other tags (such as variables) are more strict.
  if ANY_CONTENT.include?(type)
    r = /\s*#{regexp(type)}?#{regexp(current_ctag)}/
    content = scan_until_exclusive(r)
  else
    content = @scanner.scan(ALLOWED_CONTENT)
  end

  # We found {{ but we can't figure out what's going on inside.
  error "Illegal content in tag" if content.empty?

  fetch = [:mustache, :fetch, content.split('.')]
  prev = @result

  # Based on the sigil, do what needs to be done.
  case type
  when '#'
    block = [:multi]
    @result << [:mustache, :section, fetch, block]
    @sections << [content, position, @result]
    @result = block
  when '^'
    block = [:multi]
    @result << [:mustache, :inverted_section, fetch, block]
    @sections << [content, position, @result]
    @result = block
  when '/'
    section, pos, result = @sections.pop
    raw = @scanner.pre_match[pos[3]...pre_match_position] + padding
    (@result = result).last << raw << [self.otag, self.ctag]

    if section.nil?
      error "Closing unopened #{content.inspect}"
    elsif section != content
      error "Unclosed section #{section.inspect}", pos
    end
  when '!'
    # ignore comments
  when '='
    self.otag, self.ctag = content.split(' ', 2)
  when '>', '<'
    @result << [:mustache, :partial, content, padding]
  when '{', '&'
    # The closing } in unescaped tags is just a hack for
    # aesthetics.
    type = "}" if type == "{"
    @result << [:mustache, :utag, fetch]
  else
    @result << [:mustache, :etag, fetch]
  end

  # Skip whitespace and any balancing sigils after the content
  # inside this tag.
  @scanner.skip(/\s+/)
  @scanner.skip(regexp(type)) if type

  # Try to find the closing tag.
  unless close = @scanner.scan(regexp(current_ctag))
    error "Unclosed tag"
  end

  # If this tag was the only non-whitespace content on this line, strip
  # the remaining whitespace.  If not, but we've been hanging on to padding
  # from the beginning of the line, re-insert the padding as static text.
  if start_of_line && !@scanner.eos?
    if @scanner.peek(2) =~ /\r?\n/ && SKIP_WHITESPACE.include?(type)
      @scanner.skip(/\r?\n/)
    else
      prev.insert(last_index, [:static, padding]) unless padding.empty?
    end
  end

  # Store off the current scanner position now that we've closed the tag
  # and consumed any irrelevant whitespace.
  @sections.last[1] << @scanner.pos unless @sections.empty?

  return unless @result == [:multi]
end

#scan_text ⇒ Object

Try to find static text, e.g. raw HTML with no {mustaches}.



211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'lib/mustache/parser.rb', line 211

def scan_text
  text = scan_until_exclusive(/(^[ \t]*)?#{Regexp.escape(otag)}/)

  if text.nil?
    # Couldn't find any otag, which means the rest is just static text.
    text = @scanner.rest
    # Mark as done.
    @scanner.terminate
  end

  text.force_encoding(@encoding) if @encoding

  @result << [:static, text] unless text.empty?
end

#scan_until_exclusive(regexp) ⇒ Object

Scans the string until the pattern is matched. Returns the substring excluding the end of the match, advancing the scan pointer to that location. If there is no match, nil is returned.



229
230
231
232
233
234
235
 
# File 'lib/mustache/parser.rb', line 229

def scan_until_exclusive(regexp)
  pos = @scanner.pos
  if @scanner.scan_until(regexp)
    @scanner.pos -= @scanner.matched.size
    @scanner.pre_match[pos..-1]
  end
end