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"]]
Methods
C
E
N
O
P
R
S
Classes and Modules
Constants
SKIP_WHITESPACE = [ '#', '^', '/' ]
 

After these types of tags, all whitespace will be skipped.

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

The content allowed in a tag name.

ANY_CONTENT = [ '!', '=' ]
 

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

Attributes
[R] scanner
[R] result
[W] otag
[W] ctag
Class Public methods
new(options = {})

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

# File lib/mustache/parser.rb, line 63
    def initialize(options = {})
      @options = {}
    end
Instance Public methods
compile(template)

Given a string template, returns an array of tokens.

# File lib/mustache/parser.rb, line 78
    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
ctag()

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

# File lib/mustache/parser.rb, line 73
    def ctag
      @ctag ||= '}}'
    end
error(message, pos = position)

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

# File lib/mustache/parser.rb, line 227
    def error(message, pos = position)
      raise SyntaxError.new(message, pos)
    end
otag()

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

# File lib/mustache/parser.rb, line 68
    def otag
      @otag ||= '{{'
    end
position()

Returns [lineno, column, line]

# File lib/mustache/parser.rb, line 206
    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)

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

# File lib/mustache/parser.rb, line 220
    def regexp(thing)
      /#{Regexp.escape(thing)}/
    end
scan_tags()

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

# File lib/mustache/parser.rb, line 106
    def scan_tags
      # Scan until we hit an opening delimiter.
      return unless @scanner.scan(regexp(otag))

      # 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?

      # Based on the sigil, do what needs to be done.
      case type
      when '#'
        block = [:multi]
        @result << [:mustache, :section, content, block]
        @sections << [content, position, @result]
        @result = block
      when '^'
        block = [:multi]
        @result << [:mustache, :inverted_section, content, block]
        @sections << [content, position, @result]
        @result = block
      when '/'
        section, pos, result = @sections.pop
        @result = result

        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]
      when '{', '&'
        # The closing } in unescaped tags is just a hack for
        # aesthetics.
        type = "}" if type == "{"
        @result << [:mustache, :utag, content]
      else
        @result << [:mustache, :etag, content]
      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

      # Skip whitespace following this tag if we need to.
      @scanner.skip(/\s+/) if SKIP_WHITESPACE.include?(type)
    end
scan_text()

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

# File lib/mustache/parser.rb, line 179
    def scan_text
      text = scan_until_exclusive(regexp(otag))

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

      text.force_encoding(@encoding) if @encoding

      @result << [:static, text]
    end
scan_until_exclusive(regexp)

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.

# File lib/mustache/parser.rb, line 197
    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