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

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

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

#absent?Boolean

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)

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

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

98
99
100
# File 'lib/parslet/atoms/dsl.rb', line 98

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

#capture(name) ⇒ Object

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'

109
110
111
# File 'lib/parslet/atoms/dsl.rb', line 109

def capture(name)
  Parslet::Atoms::Capture.new(self, name)
end

#ignoreObject

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

45
46
47
# File 'lib/parslet/atoms/dsl.rb', line 45

def ignore
  Parslet::Atoms::Ignored.new(self)
end

#maybeObject

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

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)

88
89
90
# File 'lib/parslet/atoms/dsl.rb', line 88

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

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

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