module 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 54
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 77
def absent?
  Parslet::Atoms::Lookahead.new(self, false)
end
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 98
def as(name)
  Parslet::Atoms::Named.new(self, name)
end
capture(name) click to toggle source

Captures a part of the input and stores it under the name given. This is very useful to create self-referential parses. A capture stores the result of its parse (may be complex) on a successful parse action.

Example:

str('a').capture(:b)  # will store captures[:b] == 'a'
# File lib/parslet/atoms/dsl.rb, line 109
def capture(name)
  Parslet::Atoms::Capture.new(self, name)
end
ignore() click to toggle source

Returns a new parslet atom that will not show up in the output. This is synonymous to calling repeat(0,1). Generated tree value will always be nil.

Example:

str('foo').ignore
# File lib/parslet/atoms/dsl.rb, line 45
def ignore
  Parslet::Atoms::Ignored.new(self)
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 88
def present?
  Parslet::Atoms::Lookahead.new(self, true)
end
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 66
def |(parslet)
  Parslet::Atoms::Alternative.new(self, parslet)
end