Module: Peg::Combinators

Extended by:
Combinators
Includes:
Implementation
Included in:
All, Combinators, Parsers::AdvancedParsers, Parsers::CommonParsers
Defined in:
lib/peg.backup/combinators.rb,
lib/peg.backup/combinators/implementation.rb

Defined Under Namespace

Modules: Implementation

Instance Method Summary collapse

Methods included from Implementation

#_debug, #_lookahead, #_many, #_map_result, #_satisfy, #_select, #_sequence

Instance Method Details

#lookahead(*parsers, name: nil) ⇒ Object 



9
10
11
12
 
# File 'lib/peg.backup/combinators.rb', line 9

def lookahead(*parsers, name: nil)
  parsers = make_parsers(*parsers)
  _lookahead(parsers, name:)
end

#many(*parsers, max: nil, min: 0, name: nil) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/peg.backup/combinators.rb', line 14

def many(*parsers, max: nil, min: 0, name: nil)
  name ||= "many(#{parsers.map(&:name).join(", ")})"
  case parsers
  in []
    raise ArgumentError, "missing parser"
  in [parser]
    _many(parser, max:, min:, name:)
  in _
    many(select(*parsers), max:, min:, name:)
  end
end

#map(parser, name: nil, &mapper) ⇒ Object Also known as: _map

Raises:

  • (ArgumentError) 


26
27
28
29
30
31
32
33
 
# File 'lib/peg.backup/combinators.rb', line 26

def map(parser, name: nil, &mapper)
  raise ArgumentError, "missing mapper function" unless mapper
  raise ArgumentError, "mapper function must have arity 1" unless mapper.arity == 1
  name ||= "map(#{parser.name})"
  Parser.new(name) do |input|
    Parser.parse(parser, input).map(&mapper)
  end
end

#map_result(parser, name: nil, &mapper) ⇒ Object

Raises:

  • (ArgumentError) 


36
37
38
39
40
 
# File 'lib/peg.backup/combinators.rb', line 36

def map_result(parser, name: nil, &mapper)
  raise ArgumentError, "missing mapper function" unless mapper
  raise ArgumentError, "mapper function must have arity 1" unless mapper.arity == 1
  _map_result(parser, name || "map_result(#{parser.name})", mapper)
end

#maybe(parser, name: nil) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
 
# File 'lib/peg.backup/combinators.rb', line 42

def maybe(parser, name: nil)
  Parser.new(name || "maybe(#{parser.name})") do |input, name|
    case Parser.parse(parser, input)
    in {ok: false}
      {ok: true, ast: nil, input:}
    in success
      success
    end
  end
end

#satisfy(parser, name: nil, &satisfier) ⇒ Object

Raises:

  • (ArgumentError) 


53
54
55
56
57
 
# File 'lib/peg.backup/combinators.rb', line 53

def satisfy(parser, name: nil, &satisfier)
  raise ArgumentError, "missing satisfier block" unless satisfier
  parser = make_parser(parser)
  _satisfy(parser, name, satisfier)
end

#select(*parsers, name: nil) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
 
# File 'lib/peg.backup/combinators.rb', line 59

def select(*parsers, name: nil)
  case parsers
  in []
    raise ArgumentError, "missing parser in select"
  in [parser]
    raise ArgumentError, "one parser in a selection is a NOP, remove the select call"
  in _
    _select(*make_parsers(parsers), name)
  end
end

#sequence(*parsers, name: nil) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
 
# File 'lib/peg.backup/combinators.rb', line 70

def sequence(*parsers, name: nil)
  case parsers
  in []
    raise ArgumentError, "missing parser"
  in [parser]
    raise ArgumentError, "one parser in a sequence is a NOP, remove the sequence call"
  in _
    _sequence(make_parsers(parsers), name)
  end
end