Class: Mustache::Parser
- Inherits:
-
Object
- Object
- Mustache::Parser
- 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
-
#ctag ⇒ Object
The closing tag delimiter.
-
#otag ⇒ Object
The opening tag delimiter.
-
#result ⇒ Object
readonly
Returns the value of attribute result.
-
#scanner ⇒ Object
readonly
Returns the value of attribute scanner.
Instance Method Summary collapse
-
#compile(template) ⇒ Object
Given a string template, returns an array of tokens.
-
#error(message, pos = position) ⇒ Object
Raises a SyntaxError.
-
#initialize(options = {}) ⇒ Parser
constructor
Accepts an options hash which does nothing but may be used in the future.
-
#position ⇒ Object
Returns [lineno, column, line].
-
#regexp(thing) ⇒ Object
Used to quickly convert a string into a regular expression usable by the string scanner.
-
#scan_tags ⇒ Object
Find {mustaches} and add them to the @result array.
-
#scan_text ⇒ Object
Try to find static text, e.g.
-
#scan_until_exclusive(regexp) ⇒ Object
Scans the string until the pattern is matched.
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 = {} 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_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.
259 260 261 |
# File 'lib/mustache/parser.rb', line 259 def error(, pos = position) raise SyntaxError.new(, 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 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 |