Class Parslet::Parser
In: lib/parslet/atoms/visitor.rb
lib/parslet/parser.rb
lib/parslet/export.rb
Parent: Object

The base class for all your parsers. Use as follows:

  require 'parslet'

  class MyParser < Parslet::Parser
    rule(:a) { str('a').repeat }
    root(:a)
  end

  pp MyParser.new.parse('aaaa')   # => 'aaaa'
  pp MyParser.new.parse('bbbb')   # => Parslet::Atoms::ParseFailed:
                                  #    Don't know what to do with bbbb at line 1 char 1.

Parslet::Parser is also a grammar atom. This means that you can mix full fledged parsers freely with small parts of a different parser.

Example:

  class ParserA < Parslet::Parser
    root :aaa
    rule(:aaa) { str('a').repeat(3,3) }
  end
  class ParserB < Parslet::Parser
    root :expression
    rule(:expression) { str('b') >> ParserA.new >> str('b') }
  end

In the above example, ParserB would parse something like ‘baaab’.

Methods

accept   root   to_citrus   to_s_inner   to_treetop   try  

Included Modules

Parslet

Classes and Modules

Module Parslet::Parser::Visitors
Class Parslet::Parser::PrettyPrinter

Public Class methods

Define the parsers root function. This is the place where you start parsing; if you have a rule for ‘file’ that describes what should be in a file, this would be your root declaration:

  class Parser
    root :file
    rule(:file) { ... }
  end

root declares a ‘parse’ function that works just like the parse function that you can call on a simple parslet, taking a string as input and producing parse output.

In a way, root is a shorthand for:

  def parse(str)
    your_parser_root.parse(str)
  end

Public Instance methods

Call back visitors visit_parser method.

Exports the current parser instance as a string in the Citrus dialect.

Example:

  require 'parslet/export'
  class MyParser < Parslet::Parser
    root(:expression)
    rule(:expression) { str('foo') }
  end

  MyParser.new.to_citrus # => a citrus grammar as a string

Exports the current parser instance as a string in the Treetop dialect.

Example:

  require 'parslet/export'
  class MyParser < Parslet::Parser
    root(:expression)
    rule(:expression) { str('foo') }
  end

  MyParser.new.to_treetop # => a treetop grammar as a string

[Validate]