Class: Parslet::Parser

Inherits:
Atoms::Base show all
Includes:
Parslet
Defined in:
lib/parslet/parser.rb,
lib/parslet/export.rb,
lib/parslet/atoms/visitor.rb

Overview

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

Direct Known Subclasses

Expression::Treetop::Parser

Defined Under Namespace

Modules: Visitors Classes: PrettyPrinter

Constant Summary

Constants included from Atoms::Precedence

Atoms::Precedence::ALTERNATE, Atoms::Precedence::BASE, Atoms::Precedence::LOOKAHEAD, Atoms::Precedence::OUTER, Atoms::Precedence::REPETITION, Atoms::Precedence::SEQUENCE

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Parslet

any, exp, included, match, sequence, simple, str, subtree

Methods inherited from Atoms::Base

#apply, #inspect, #parse, #parse_with_debug, precedence, #setup_and_apply, #to_s

Methods included from Atoms::CanFlatten

#flatten, #flatten_repetition, #flatten_sequence, #foldl, #merge_fold, #warn_about_duplicate_keys

Methods included from Atoms::DSL

#>>, #absent?, #as, #maybe, #present?, #repeat, #|

Class Method Details

.root(name) ⇒ Object

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



53
54
55
56
57
 
# File 'lib/parslet/parser.rb', line 53

def root(name)
  define_method(:root) do
    self.send(name)
  end
end

Instance Method Details

#accept(visitor) ⇒ Object

Call back visitors #visit_parser method.



86
87
88
 
# File 'lib/parslet/atoms/visitor.rb', line 86

def accept(visitor)
  visitor.visit_parser(root)
end

#to_citrus ⇒ Object

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



140
141
142
143
 
# 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) ⇒ Object 



64
65
66
 
# File 'lib/parslet/parser.rb', line 64

def to_s_inner(prec)
  root.to_s(prec)
end

#to_treetop ⇒ Object

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



157
158
159
160
 
# File 'lib/parslet/export.rb', line 157

def to_treetop
  PrettyPrinter.new(Visitors::Treetop).
    pretty_print(self.class.name, root)
end

#try(source, context) ⇒ Object 



60
61
62
 
# File 'lib/parslet/parser.rb', line 60

def try(source, context)
  root.try(source, context)
end