Module: EBNF::PEG::Parser::ClassMethods

Defined in:
lib/ebnf/peg/parser.rb

Overview

DSL for creating terminals and productions

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object (private) 



152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/ebnf/peg/parser.rb', line 152

def method_missing(method, *args, &block)
  if @delegate ||= nil
    # special handling when last arg is **options
    params = @delegate.method(method).parameters
    if params.any? {|t, _| t == :keyrest} && args.last.is_a?(Hash)
      opts = args.pop
      @delegate.send(method, *args, **opts, &block)
    else
      @delegate.send(method, *args, &block)
    end
  else
    super
  end
end

Instance Method Details

#eval_with_binding(object) ⇒ Object

Evaluate a handler, delegating to the specified object. This is necessary so that handlers can operate within the binding context of the parser in which they’re invoked.

Parameters:

  • object (Object)

Returns:

  • (Object) 


145
146
147
148
 
# File 'lib/ebnf/peg/parser.rb', line 145

def eval_with_binding(object)
  @delegate = object
  object.instance_eval {yield}
end

#production(term, clear_packrat: false) {|result, data, block| ... } ⇒ Object

Defines a production called when production of associated non-terminals has completed with data from previous production along with data defined for the current production. Block is called in an evaluation block from the enclosing parser.

Yield to generate a triple

Parameters:

  • term (Symbol) —

    Term which is a key in the branch table

  • clear_packrat (Boolean) (defaults to: false) —

    (false) Clears the packrat state on completion to reduce memory requirements of parser. Use only on a top-level rule when it is determined that no further backtracking is necessary.

Yields:

  • (result, data, block)

Yield Parameters:

  • result (Object) —

    The result from sucessfully parsing the production.

  • data (Hash) —

    A Hash defined for the current production, during :start may be initialized with data to pass to further productions, during :finish, it contains data placed by earlier productions

  • block (Proc) —

    Block passed to initialization for yielding to calling parser. Should conform to the yield specs for #initialize

Yield Returns:

  • (Object) —

    the result of this production.



136
137
138
 
# File 'lib/ebnf/peg/parser.rb', line 136

def production(term, clear_packrat: false, &block)
  production_handlers[term] = [block, clear_packrat]
end

#production_handlers ⇒ Object 



54
 
# File 'lib/ebnf/peg/parser.rb', line 54

def production_handlers; (@production_handlers ||= {}); end

#start_handlers ⇒ Object 



53
 
# File 'lib/ebnf/peg/parser.rb', line 53

def start_handlers; (@start_handlers ||= {}); end

#start_production(term) {|data, block| ... } ⇒ Object

Defines a production called at the beggining of a particular production with data from previous production along with data defined for the current production. Block is called in an evaluation block from the enclosing parser.

Yield to generate a triple

Parameters:

  • term (Symbol) —

    The rule name

Yields:

  • (data, block)

Yield Parameters:

  • data (Hash) —

    A Hash defined for the current production, during :start may be initialized with data to pass to further productions, during :finish, it contains data placed by earlier productions

  • block (Proc) —

    Block passed to initialization for yielding to calling parser. Should conform to the yield specs for #initialize



109
110
111
 
# File 'lib/ebnf/peg/parser.rb', line 109

def start_production(term, &block)
  start_handlers[term] = block
end

#terminal(term, regexp = nil, **options) {|value, prod| ... } ⇒ Object

Defines the pattern for a terminal node and a block to be invoked when ther terminal is encountered. If the block is missing, the value of the terminal will be placed on the input hash to be returned to a previous production. Block is called in an evaluation block from the enclosing parser.

If no block is provided, then the value which would have been passed to the block is used as the result directly.

Parameters:

  • term (Symbol) —

    The terminal name.

  • regexp (Regexp) (defaults to: nil) —

    (nil) Pattern used to scan for this terminal, defaults to the expression defined in the associated rule. If unset, the terminal rule is used for matching.

  • options (Hash)

Options Hash (**options):

  • :map (Hash{String => String}) — default: {} —

    A mapping from terminals, in lower-case form, to their canonical value

  • :unescape (Boolean) —

    Cause strings and codepoints to be unescaped.

Yields:

  • (value, prod)

Yield Parameters:

  • value (String) —

    The scanned terminal value.

  • prod (Symbol) —

    A symbol indicating the production which referenced this terminal

  • block (Proc) —

    Block passed to initialization for yielding to calling parser. Should conform to the yield specs for #initialize



87
88
89
90
 
# File 'lib/ebnf/peg/parser.rb', line 87

def terminal(term, regexp = nil, **options, &block)
  terminal_regexps[term] = regexp if regexp
  terminal_handlers[term] = block if block_given?
end

#terminal_handlers ⇒ Object 



55
 
# File 'lib/ebnf/peg/parser.rb', line 55

def terminal_handlers; (@terminal_handlers ||= {}); end

#terminal_regexps ⇒ Object 



56
 
# File 'lib/ebnf/peg/parser.rb', line 56

def terminal_regexps; (@terminal_regexps ||= {}); end