Module: Parslet::Atoms::DSL

Included in:
Base
Defined in:
lib/parslet/atoms/dsl.rb

Overview

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

Instance Method Summary collapse

Instance Method Details

#>>(parslet) ⇒ Object

Chains two parslet atoms together as a sequence.

Example: 

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



43
44
45
 
# File 'lib/parslet/atoms/dsl.rb', line 43

def >>(parslet)
  Parslet::Atoms::Sequence.new(self, parslet)
end

#absent? ⇒ Boolean Also known as: absnt?

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?

Returns:

  • (Boolean) 


66
67
68
 
# File 'lib/parslet/atoms/dsl.rb', line 66

def absent?
  Parslet::Atoms::Lookahead.new(self, false)
end

#as(name) ⇒ Object

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'}



95
96
97
 
# File 'lib/parslet/atoms/dsl.rb', line 95

def as(name)
  Parslet::Atoms::Named.new(self, name)
end

#maybe ⇒ Object

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



34
35
36
 
# File 'lib/parslet/atoms/dsl.rb', line 34

def maybe
  Parslet::Atoms::Repetition.new(self, 0, 1, :maybe)
end

#present? ⇒ Boolean Also known as: prsnt?

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?

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/parslet/atoms/dsl.rb', line 77

def present?
  Parslet::Atoms::Lookahead.new(self, true)
end

#repeat(min = 0, max = nil) ⇒ Object

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)



23
24
25
 
# File 'lib/parslet/atoms/dsl.rb', line 23

def repeat(min=0, max=nil)
  Parslet::Atoms::Repetition.new(self, min, max)
end

#|(parslet) ⇒ Object

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')



55
56
57
 
# File 'lib/parslet/atoms/dsl.rb', line 55

def |(parslet)
  Parslet::Atoms::Alternative.new(self, parslet)
end