Module: L43Peg::Combinators

Extended by:
Combinators
Includes:
Helper, Mappers, Parsers
Included in:
Combinators, Parsers::IntParser
Defined in:
lib/l43_peg/combinators.rb,
lib/l43_peg/combinators/sel.rb,
lib/l43_peg/combinators/seq.rb,
lib/l43_peg/combinators/many.rb,
lib/l43_peg/combinators/debug_parser.rb

Defined Under Namespace

Modules: DebugParser, Many, Sel, Seq

Instance Method Summary collapse

Methods included from Parsers

#char_parser, #end_parser, #failure_parser, #int_parser, #rgx_parser, #token_parser, #tokens_parser, #verb_parser

Methods included from Mappers

#join_and_to_i, #join_maps

Methods included from Helper

#fail_parser, #succeed_parser

Instance Method Details

#args_parser(definitions, name: nil, stop: nil, &block) ⇒ Object 



18
19
20
21
22
23
 
# File 'lib/l43_peg/combinators.rb', line 18

def args_parser(definitions, name: nil, stop: nil, &block)
  parser = tokens_parser(definitions, stop:, &block)
  name   = name || "args_parser(#{definitions.inspect})"
  inner  = many(parser)
  map(inner, name:, fn: join_maps)
end

#debug_parser(parser, name: nil, level: :default) ⇒ Object 



25
26
27
28
 
# File 'lib/l43_peg/combinators.rb', line 25

def debug_parser(parser, name: nil, level: :default)
  name ||= "debug_parser(#{parser.name})"
  Parser.new(name, &DebugParser.parse_with_debug(parser:, level:, name:))
end

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



30
31
32
 
# File 'lib/l43_peg/combinators.rb', line 30

def many(parser, name: nil, min: 0, max: nil)
  Parser.new(name || "many(#{parser.name})") {|input, cache, name1=nil| Many.many(input:, cache:, name: name1 || name, parser:, min:, max:)}
end

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

Raises:

  • (ArgumentError) 


34
35
36
37
38
39
 
# File 'lib/l43_peg/combinators.rb', line 34

def map(parser, name: nil, fn: nil, &mapper)
  raise ArgumentError, "must not provide keyword parameyer fn and a block" if fn && mapper
  mapper = fn || mapper
  raise ArgumentError, "must provide keyword parameyer fn or a block" unless mapper
  Parser.new(name || "map(#{parser.name})") {|input, cache, name=nil| _map(input:, cache:, name:, parser:, mapper:)}
end

#rgx_tokenize(rgx_specs, name: nil) ⇒ Object 



41
42
43
44
 
# File 'lib/l43_peg/combinators.rb', line 41

def rgx_tokenize(rgx_specs, name: nil)
  name = name || "rgx_tokenize(#{rgx_specs.inspect})"
  many(sel_rgx_parser(rgx_specs, name:))
end

#sel(parsers, name: nil) ⇒ Object 



46
47
48
49
 
# File 'lib/l43_peg/combinators.rb', line 46

def sel(parsers, name: nil)
  name ||= "sel(#{parsers.map(&:name).join(", ")})"
  Parser.new(name) { |input, cache, name1=nil| Sel.sel(input:, cache:, name: name1 || name, parsers:) }
end

#sel_rgx_parser(rgx_specs, name: nil) ⇒ Object 



51
52
53
54
55
 
# File 'lib/l43_peg/combinators.rb', line 51

def sel_rgx_parser(rgx_specs, name: nil)
  name = name || "sel_rgx_parser(#{rgx_specs.inspect})"
  parsers = rgx_specs.map(&_mk_rgx_parser)
  sel(parsers, name:)
end

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



57
58
59
60
 
# File 'lib/l43_peg/combinators.rb', line 57

def seq(*parsers, name: nil)
  name ||= "seq(#{parsers.map(&:name).join(", ")})"
  Parser.new(name) {|input, cache, _name=nil| Seq.seq(input:, cache:, name:, parsers:)}
end