Class: Parslet::Parser

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

Overview

reopen for introducing the .graph method

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

Instance Attribute Summary

Attributes inherited from Atoms::Base

#label

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Graphable

graph

Methods included from Parslet

any, dynamic, exp, included, infix_expression, match, scope, sequence, simple, str, subtree

Methods inherited from Atoms::Base

#apply, #cached?, #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, #capture, #ignore, #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
58
# 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

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_citrusObject

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


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

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

#to_treetopObject

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, consume_all) ⇒ Object


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

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