Module: Paco::Combinators::Char

Included in:
Paco::Combinators, Paco::Combinators
Defined in:
lib/paco/combinators/char.rb

Instance Method Summary collapse

Instance Method Details

#any_char ⇒ Paco::Parser

Returns a parser that consumes and returns the next character of the input.

Returns:



86
87
88
 
# File 'lib/paco/combinators/char.rb', line 86

def any_char
  memoize { satisfy("any_char") { |ch| ch.length > 0 } }
end

#cr ⇒ Paco::Parser

Returns a parser that checks for the “carriage return” (\r) character.

Returns:



123
124
125
 
# File 'lib/paco/combinators/char.rb', line 123

def cr
  memoize { string("\r") }
end

#crlf ⇒ Paco::Parser

Returns a parser that checks for the “carriage return” character followed by the “line feed” character (‘rn`).

Returns:



135
136
137
 
# File 'lib/paco/combinators/char.rb', line 135

def crlf
  memoize { string("\r\n") }
end

#digit ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp_char(//)`.

Returns:



171
172
173
 
# File 'lib/paco/combinators/char.rb', line 171

def digit
  memoize { regexp_char(/[0-9]/) }
end

#digits ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp(/+/)`.

Returns:



177
178
179
 
# File 'lib/paco/combinators/char.rb', line 177

def digits
  memoize { regexp(/[0-9]+/) }
end

#end_of_line ⇒ Paco::Parser

Returns a parser that will match any kind of line ending including end of file.

Returns:



147
148
149
 
# File 'lib/paco/combinators/char.rb', line 147

def end_of_line
  memoize { alt(newline, eof) }
end

#eof ⇒ Paco::Parser

Returns a parser that matches end of file and returns nil.

Returns:



112
113
114
115
116
117
118
119
 
# File 'lib/paco/combinators/char.rb', line 112

def eof
  memoize do
    Parser.new("end of file") do |ctx, parser|
      parser.failure(ctx) unless ctx.eof?
      nil
    end
  end
end

#letter ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp_char(//i)`.

Returns:



153
154
155
 
# File 'lib/paco/combinators/char.rb', line 153

def letter
  memoize { regexp_char(/[a-z]/i) }
end

#letters ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp(/+/i)`.

Returns:



159
160
161
 
# File 'lib/paco/combinators/char.rb', line 159

def letters
  memoize { regexp(/[a-z]+/i) }
end

#lf ⇒ Paco::Parser

Returns a parser that checks for the “line feed” (\n) character.

Returns:



129
130
131
 
# File 'lib/paco/combinators/char.rb', line 129

def lf
  memoize { string("\n") }
end

#newline ⇒ Paco::Parser

Returns a parser that will match any kind of line ending.

Returns:



141
142
143
 
# File 'lib/paco/combinators/char.rb', line 141

def newline
  memoize { alt(crlf, lf, cr) }
end

#none_of(matcher) ⇒ Paco::Parser

Returns a parser that looks for exactly one character NOT from passed matcher, and returns its value on success.

Parameters:

  • matcher (String, Array<String>)

Returns:



80
81
82
 
# File 'lib/paco/combinators/char.rb', line 80

def none_of(matcher)
  satisfy("none_of(#{matcher})") { |char| !matcher.include?(char) }
end

#one_of(matcher) ⇒ Paco::Parser

Returns a parser that looks for exactly one character from passed matcher, and returns its value on success.

Parameters:

  • matcher (String, Array<String>)

Returns:



72
73
74
 
# File 'lib/paco/combinators/char.rb', line 72

def one_of(matcher)
  satisfy("one_of(#{matcher})") { |char| matcher.include?(char) }
end

#opt_digits ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp(/*/)`.

Returns:



183
184
185
 
# File 'lib/paco/combinators/char.rb', line 183

def opt_digits
  memoize { regexp(/[0-9]*/) }
end

#opt_letters ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp(/*/i)`.

Returns:



165
166
167
 
# File 'lib/paco/combinators/char.rb', line 165

def opt_letters
  memoize { regexp(/[a-z]*/i) }
end

#opt_ws ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp(/s*/)`.

Returns:



195
196
197
 
# File 'lib/paco/combinators/char.rb', line 195

def opt_ws
  memoize { regexp(/\s*/) }
end

#regexp(regexp, group: 0) ⇒ Paco::Parser

Returns a parser that looks for a match to the regexp and returns the entire text matched. The regexp will always match starting at the current parse location. When group is specified, it returns only the text in the specific regexp match group.

Parameters:

  • regexp (Regexp)
  • group (Integer) (defaults to: 0)

Returns:



50
51
52
53
54
55
56
57
58
59
 
# File 'lib/paco/combinators/char.rb', line 50

def regexp(regexp, group: 0)
  anchored_regexp = Regexp.new("\\A(?:#{regexp.source})", regexp.options)
  Parser.new("regexp(#{regexp.inspect})") do |ctx, parser|
    match = anchored_regexp.match(ctx.read_all)
    parser.failure(ctx) if match.nil?

    ctx.pos += match[0].length
    match[group]
  end
end

#regexp_char(regexp) ⇒ Paco::Parser

Returns a parser that checks current character against the passed regexp

Parameters:

  • regexp (Regexp)

Returns:



64
65
66
 
# File 'lib/paco/combinators/char.rb', line 64

def regexp_char(regexp)
  satisfy("regexp_char(#{regexp.inspect})") { |char| regexp.match?(char) }
end

#remainder ⇒ Paco::Parser

Returns a parser that consumes and returns the entire remainder of the input.

Returns:



92
93
94
95
96
97
98
99
100
 
# File 'lib/paco/combinators/char.rb', line 92

def remainder
  memoize do
    Parser.new("remainder") do |ctx, parser|
      result = ctx.read_all
      ctx.pos += result.length
      result
    end
  end
end

#satisfy(desc = "", &block) ⇒ Paco::Parser

Returns a parser that returns a single character if passed block result is truthy:

lower = Combinators.satisfy do |char|

char == char.downcase

end

lower.parse(“a”) #=> “a” lower.parse(“P”) #=> ParseError

Parameters:

  • desc (String) (defaults to: "") —

    optional description for the parser

  • block (Proc) —

    proc with one argument – a next char of the input

Returns:



19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/paco/combinators/char.rb', line 19

def satisfy(desc = "", &block)
  Parser.new(desc) do |ctx, parser|
    parser.failure(ctx) if ctx.eof?

    char = ctx.read(1)
    parser.failure(ctx) unless block.call(char)

    ctx.pos += 1
    char
  end
end

#spaced(parser) ⇒ Paco::Parser

Alias for ‘parser.trim(Paco::Combinators.opt_ws)`.

Parameters:

Returns:



202
203
204
 
# File 'lib/paco/combinators/char.rb', line 202

def spaced(parser)
  parser.trim(opt_ws)
end

#string(matcher) ⇒ Paco::Parser

Returns a parser that looks for a passed matcher string and returns its value on success.

Parameters:

  • matcher (String)

Returns:



34
35
36
37
38
39
40
41
42
 
# File 'lib/paco/combinators/char.rb', line 34

def string(matcher)
  Parser.new("string(#{matcher.inspect})") do |ctx, parser|
    src = ctx.read(matcher.length)
    parser.failure(ctx) if src != matcher

    ctx.pos += matcher.length
    src
  end
end

#take_while(&block) ⇒ Paco::Parser

Returns a parser that returns a string containing all the next characters that are truthy for the passed block.

Parameters:

  • block (Proc) —

    proc with one argument – a next char of the input

Returns:



106
107
108
 
# File 'lib/paco/combinators/char.rb', line 106

def take_while(&block)
  satisfy(&block).many.join
end

#ws ⇒ Paco::Parser

Alias for ‘Paco::Combinators.regexp(/s+/)`.

Returns:



189
190
191
 
# File 'lib/paco/combinators/char.rb', line 189

def ws
  memoize { regexp(/\s+/) }
end