class Parslet::Parser

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

Public Instance Methods

accept(visitor) click to toggle source

Call back visitors visit_parser method.

# File lib/parslet/atoms/visitor.rb, line 86
def accept(visitor)
  visitor.visit_parser(root)
end

to_citrus() click to toggle source

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

# File lib/parslet/export.rb, line 140
def to_citrus
  PrettyPrinter.new(Visitors::Citrus).
    pretty_print(self.class.name, root)
end

to_s_inner(prec) click to toggle source

# File lib/parslet/parser.rb, line 65
def to_s_inner(prec)
  root.to_s(prec)
end

to_treetop() click to toggle source

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

# File lib/parslet/export.rb, line 157
def to_treetop
  PrettyPrinter.new(Visitors::Treetop).
    pretty_print(self.class.name, root)
end

try(source, context, consume_all) click to toggle source

# File lib/parslet/parser.rb, line 61
def try(source, context, consume_all)
  root.try(source, context, consume_all)
end

Public Class Methods

root(name) click to toggle source

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

# File lib/parslet/parser.rb, line 53
def root(name)
  undef_method :root if method_defined? :root
  define_method(:root) do
    self.send(name)
  end
end