Module: NonTerminalNode

Defined in:
lib/rubypeg.rb

Overview

By default all non terminals that are returned by RubyPeg#parse are Arrays that have been extended with the NonTerminalNode module

If we consider this example:

class BasketPeg < RubyPeg
  def root
    node :basket do
      one_or_more { items }
    end
  end

  def items
    node :item do
      number && optional_space && fruit && optional_space
    end
  end

  def number
    terminal(/\d+/)
  end

  def fruit
    node :fruit do
      (terminal("apple") || terminal("pear")) && ignore{ optional{ terminal("s") } }
    end
  end

  def optional_space
    ignore{ optional{ terminal(" ") }}
  end
end

Then

BasketPeg.parse("1 apple 2 apples 3 pears").should be_kind_of(NonTerminalNode)

This is an array of children of this non terminal. The children may be other non-terminals or terminals The array will be empty if there are no children.

basket = BasketPeg.parse("1 apple 2 apples 3 pears")
basket.class.should == Array
basket.size.should == 3
basket.first.should be_kind_of(NonTerminalNode)
basket.first.type.should == :item
basket.first.class.should == Array
basket.first.size.should == 2
basket.first.first.should be_kind_of(TerminalNode)
basket.first.first.should == "1"
basket.first.last.should be_kind_of(NonTerminalNode)
basket.first.last.type == :fruit
basket.first.last.class.should == Array
basket.first.last.size.should == 1
basket.first.last.first.should be_kind_of(TerminalNode)
basket.first.last.first.should == "apple"

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#type ⇒ Object

Contains the argument given to RubyPeg#node

BasketPeg.parse("1 apple 2 apples 3 pears").type.should == :basket



67
68
69
 
# File 'lib/rubypeg.rb', line 67

def type
  @type
end

Instance Method Details

#inspect ⇒ Object

Lists the non-terminal node and its children. Same content as #to_ast but in string form.

BasketPeg.parse("1 apple 2 apples 3 pears").inspect.should == '[:basket, [:item, "1", [:fruit, "apple"]], [:item, "2", [:fruit, "apple"]], [:item, "3", [:fruit, "pear"]]]'



119
 
# File 'lib/rubypeg.rb', line 119

def inspect; to_ast.inspect end

#to_ast ⇒ Object

Returns the node network as an abstract syntax tree

BasketPeg.parse("1 apple 2 apples 3 pears").to_ast.should == [:basket, [:item, "1", [:fruit, "apple"]], [:item, "2", [:fruit, "apple"]], [:item, "3", [:fruit, "pear"]]]

Note that the items wrapped in ignore {} in the parser, shuch as the spaces and the optional ‘s’ in apples and pears do not appear.



113
114
115
 
# File 'lib/rubypeg.rb', line 113

def to_ast
  [type,*self.map(&:to_ast)]
end

#to_s ⇒ Object

Returns the result of calling to_s on each of its children. By default, TerminalNode#to_s returns its text value, so:

BasketPeg.parse("1 apple 2 apples 3 pears").to_s.should == "1apple2apple3pear"

Note that the items wrapped in ignore {} in the parser, shuch as the spaces and the optional ‘s’ in apples and pears do not appear.



124
 
# File 'lib/rubypeg.rb', line 124

def to_s; self.map(&:to_s).join end

#visit(builder = nil) ⇒ Object

This is a quick way of carrying out the visitor pattern on the parsed structure.

If no visitor is supplied then a nested array of child nodes is returned, with terminals turned into strings:

BasketPeg.parse("1 apple 2 apples 3 pears").build.should == [["1", "apple"], ["2", "apple"], ["3", "pear"]]

If a visitor is supplied, then each non terminal node checks if there is a method on the visitor with a name the same as the non terminal’s type. If there is, then the method is called with the children of the non terminal as arguments. If there isn’t, then the build methods on the children of this node ar recursively called. E.g.,:

BasketPeg.parse("1 apple 2 apples 3 pears").build.should == [["1", "apple"], ["2", "apple"], ["3", "pear"]]
class BasketPegBuilderExample
  attr_accessor :total

  def initialize
    @total = 0
  end

  def item(number,kind)
    @total = @total + (number.to_f * kind.build(self).to_f)
  end

  def fruit(kind_of_fruit)
    case kind_of_fruit
    when "apple"; 3.0
    when "pear"; 1.0
    else  10.0
    end
  end
end
counter = BasketPegBuilderExample.new
BasketPeg.parse("1 apple 2 apples 3 pears").build(counter)
counter.total.should == 12.0



103
104
105
106
107
 
# File 'lib/rubypeg.rb', line 103

def visit(builder = nil)
  return builder.send(type,*self) if builder.respond_to?(type)
  return self.first.visit(builder) if self.size == 1
  self.map { |c| c.visit(builder) }
end