Class: Parslet::Parser

### Home Classes Methods

### In Files

- lib/parslet/atoms/visitor.rb
- lib/parslet/export.rb
- lib/parslet/parser.rb

### Parent

Parslet::Atoms::Base

### Namespace

- MODULE Parslet::Parser::Visitors
- CLASS Parslet::Parser::PrettyPrinter

### Methods

- ::root
- #accept
- #to_citrus
- #to_s_inner
- #to_treetop
- #try

### Included Modules

- Parslet

### Files

- README

### Class/Module Index

Quicksearch

- Parslet
- Parslet::Atoms
- Parslet::Atoms::Alternative
- Parslet::Atoms::Base
- Parslet::Atoms::CanFlatten
- Parslet::Atoms::Capture
- Parslet::Atoms::Context
- Parslet::Atoms::DSL
- Parslet::Atoms::Dynamic
- Parslet::Atoms::Entity
- Parslet::Atoms::Lookahead
- Parslet::Atoms::Named
- Parslet::Atoms::Precedence
- Parslet::Atoms::Re
- Parslet::Atoms::Repetition
- Parslet::Atoms::Scope
- Parslet::Atoms::Sequence
- Parslet::Atoms::Str
- Parslet::Cause
- Parslet::ClassMethods
- Parslet::DelayedMatchConstructor
- Parslet::ErrorReporter
- Parslet::ErrorReporter::Deepest
- Parslet::ErrorReporter::Tree
- Parslet::Expression
- Parslet::Expression::Treetop
- Parslet::Expression::Treetop::Parser
- Parslet::Expression::Treetop::Transform
- Parslet::ParseFailed
- Parslet::Parser
- Parslet::Parser::PrettyPrinter
- Parslet::Parser::Visitors
- Parslet::Parser::Visitors::Citrus
- Parslet::Parser::Visitors::Treetop
- Parslet::Pattern
- Parslet::Pattern::SequenceBind
- Parslet::Pattern::SimpleBind
- Parslet::Pattern::SubtreeBind
- Parslet::Scope
- Parslet::Scope::Binding
- Parslet::Scope::NotFound
- Parslet::Slice
- Parslet::Source
- Parslet::Source::LineCache
- Parslet::Source::RangeSearch
- Parslet::Transform
- Parslet::Transform::Context

No matching classes.

# 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 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)
      define_method(:root) do
        self.send(name)
      end
    end

### 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 64
    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 60
    def try(source, context, consume_all)
      root.try(source, context, consume_all)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.