Module: Parslet::Atoms::DSL

### Home Classes Methods

### In Files

- lib/parslet/atoms/dsl.rb

### Methods

- #>>
- #absent?
- #absnt?
- #as
- #maybe
- #present?
- #prsnt?
- #repeat
- #|

### Files

- README

### Class/Module Index

Quicksearch

- Parslet
- Parslet::Atoms
- Parslet::Atoms::Alternative
- Parslet::Atoms::Base
- Parslet::Atoms::CanFlatten
- Parslet::Atoms::Context
- Parslet::Atoms::DSL
- Parslet::Atoms::Entity
- Parslet::Atoms::Lookahead
- Parslet::Atoms::Named
- Parslet::Atoms::Precedence
- Parslet::Atoms::Re
- Parslet::Atoms::Repetition
- 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::Slice
- Parslet::Source
- Parslet::Source::LineCache
- Parslet::Source::RangeSearch
- Parslet::Transform
- Parslet::Transform::Context
- Parslet::UnconsumedInput

No matching classes.

# Parslet::Atoms::DSL

A mixin module that defines operations that can be called on any subclass of Parslet::Atoms::Base. These operations make parslets atoms chainable and allow combination of parslet atoms to form bigger parsers.

Example:

    str('foo') >> str('bar')
    str('f').repeat
    any.absent?               # also called The Epsilon

### Public Instance Methods

>>(parslet) click to toggle source

Chains two parslet atoms together as a sequence.

Example:

    str('a') >> str('b')

    # File lib/parslet/atoms/dsl.rb, line 43
    def >>(parslet)
      Parslet::Atoms::Sequence.new(self, parslet)
    end

absent?() click to toggle source

Tests for absence of a parslet atom in the input stream without consuming it.

Example:

    # Only proceed the parse if 'a' is absent.
    str('a').absent?

    # File lib/parslet/atoms/dsl.rb, line 66
    def absent?
      Parslet::Atoms::Lookahead.new(self, false)
    end

Also aliased as: absnt?
absnt?() click to toggle source

Alias for absent? that will disappear in 2.0 (deprecated)

Alias for: absent?
as(name) click to toggle source

Marks a parslet atom as important for the tree output. This must be used to achieve meaningful output from the parse method.

Example:

    str('a').as(:b) # will produce {:b => 'a'}

    # File lib/parslet/atoms/dsl.rb, line 95
    def as(name)
      Parslet::Atoms::Named.new(self, name)
    end

maybe() click to toggle source

Returns a new parslet atom that is only maybe present in the input. This is synonymous to calling repeat(0,1). Generated tree value will be either nil (if atom is not present in the input) or the matched subtree.

Example:

    str('foo').maybe

    # File lib/parslet/atoms/dsl.rb, line 34
    def maybe
      Parslet::Atoms::Repetition.new(self, 0, 1, :maybe)
    end

present?() click to toggle source

Tests for presence of a parslet atom in the input stream without consuming it.

Example:

    # Only proceed the parse if 'a' is present.
    str('a').present?

    # File lib/parslet/atoms/dsl.rb, line 77
    def present?
      Parslet::Atoms::Lookahead.new(self, true)
    end

Also aliased as: prsnt?
prsnt?() click to toggle source

Alias for present? that will disappear in 2.0 (deprecated)

Alias for: present?
repeat(min=0, max=nil) click to toggle source

Construct a new atom that repeats the current atom min times at least and at most max times. max can be nil to indicate that no maximum is present.

Example:

    # match any number of 'a's
    str('a').repeat

    # match between 1 and 3 'a's
    str('a').repeat(1,3)

    # File lib/parslet/atoms/dsl.rb, line 23
    def repeat(min=0, max=nil)
      Parslet::Atoms::Repetition.new(self, min, max)
    end

|(parslet) click to toggle source

Chains two parslet atoms together to express alternation. A match will always be attempted with the parslet on the left side first. If it doesn't match, the right side will be tried.

Example:

    # matches either 'a' OR 'b'
    str('a') | str('b')

    # File lib/parslet/atoms/dsl.rb, line 55
    def |(parslet)
      Parslet::Atoms::Alternative.new(self, parslet)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.