Class: MustacheRender::Mustache::Parser

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



66
67
68
 
# File 'lib/mustache_render/mustache/parser.rb', line 66

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

Instance Attribute Details

#ctag ⇒ Object

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



76
77
78
 
# File 'lib/mustache_render/mustache/parser.rb', line 76

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

#otag ⇒ Object

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



71
72
73
 
# File 'lib/mustache_render/mustache/parser.rb', line 71

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

#result ⇒ Object (readonly)

Returns the value of attribute result.



61
62
63
 
# File 'lib/mustache_render/mustache/parser.rb', line 61

def result
  @result
end

#scanner ⇒ Object (readonly)

Returns the value of attribute scanner.



61
62
63
 
# File 'lib/mustache_render/mustache/parser.rb', line 61

def scanner
  @scanner
end

Instance Method Details

#compile(template) ⇒ Object

Given a string template, returns an array of tokens.



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

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:



261
262
263
 
# File 'lib/mustache_render/mustache/parser.rb', line 261

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

#position ⇒ Object

Returns [lineno, column, line]



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

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.



254
255
256
 
# File 'lib/mustache_render/mustache/parser.rb', line 254

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

#scan_tags ⇒ Object

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



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
209
210
 
# File 'lib/mustache_render/mustache/parser.rb', line 109

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}.



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

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.



231
232
233
234
235
236
237
 
# File 'lib/mustache_render/mustache/parser.rb', line 231

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