treebank 2.1.0 → 3.0.0

data/README

@@ -1,64 +1,67 @@
-= Tree Module
+= Tree Representation Module
 
-This module supports the creation, search, manipulation, and
-serialization of tree structures.
+This module supports the creation, search, manipulation, and serialization of tree structures.
 
-Trees are implemented with Treebank::Node objects.  Each Node has a writable
-_label_ that may be any arbitrary object and a list of other child
-Node objects.  Node objects support breadth and depth first iteration.
+Trees are implemented with Treebank::Node objects.  Each Node has a writable _label_ that may be any arbitrary object and a list of other child Node objects.
 
-   irb(main):001:0> require 'treebank'
+   > require 'treebank'
    => true
-   irb(main):002:0> p = Treebank::Node.new('parent')
+   > p = Treebank::Node.new('parent')
    => <Treebank::Node parent []>
-   irb(main):003:0> p.create_child!('child1')
+   > p.create_child!('child1')
    => <Treebank::Node child1 []>
-   irb(main):004:0> p.create_child!('child2')
+   > p.create_child!('child2')
    => <Treebank::Node child2 []>
 
-Node has a subclass Treebank::ParentedNode that keeps track of the parent of the
-given node and has methods for iterating up the ancestor tree.
+Node has a subclass Treebank::ParentedNode that keeps track of the parent of the given node and has methods for iterating up the ancestor tree.
 
-The default stringification method writes a node and all its children
-in a bracketed tree format.
+Node objects support breadth- and depth-first iteration. The functions each_depth_first and each_breadth_first yield a node and its descendants in the specified order.  The functions depth_first_enumerator and breadth_first_enumerator wrap these functions inside Enumerator[http://www.ruby-doc.org/core/classes/Enumerable/Enumerator.html] objects.  See the function documentation for details as to how the enumeration may be controlled.
 
-   irb(main):005:0> puts p
+The default stringification method writes a node and all its children in a bracketed tree format.
+
+   > puts p
    (parent
      (child1 )
      (child2 ))
 
 Bracketed tree strings can be used to create Node trees.
 
-   irb(main):006:0> t = Treebank::Node.from_s('(parent (child1) (child2))')
+   > t = Treebank::Node.from_s('(parent (child1) (child2))')
    => <Treebank::Node parent [child1 child2]>
-   irb(main):007:0> puts t
+   > puts t
    (parent
      (child1 )
      (child2 ))
 
-The bracketed tree format is the one used by the Penn
-Treebank[http://www.cis.upenn.edu/~treebank/] Project to annonate
-linguistic structure.
+The bracketed tree format is the one used by the {Penn Treebank Project}[http://www.cis.upenn.edu/~treebank] to annotate linguistic structure.
+
+The children of a node can be dereferenced with the array operator using a list of child offsets. For example:
+
+	> t = Treebank::Node.from_s("(A (B b) (C (D d) (E e)))")
+	=> <Treebank::Node A [B C]>
+	> t[1,0]
+	=> <Treebank::Node D [d]>
+
+Here the index (1,0) finds the 0th child of the node's 1st child, which is the node <tt>(D d)</tt>.
 
 = History
 
-* 1-0-0 ... First release
-* 1-1-0 ... Removed unnecessary fsa dependency from gemspec
-* 2-0-0 ... Changed from_s initialization
-* 2-1-0 ... Add indented multiline stringification; Add preterminal?
+1-0-0:: First release
+1-1-0:: Removed unnecessary fsa dependency from gemspec
+2-0-0:: Changed from_s initialization
+2-1-0:: Add indented multiline stringification; Add preterminal?
+3-0-0:: Add Node.children function. Add child deferencing by index. The each_depth_first and each_breadth_first functions now yield nodes instead of returning private enumerator objects.  To get enumerator objects, use depth_first_enumerator and breadth_first_enumerator instead.  Likewise, the each_parent function in the ParentedNode class yields nodes, while parent_enumerator returns an enumerator.
 
 = See Also
 
-Lingua::Treebank[http://search.cpan.org/~kahn/Lingua-Treebank-0.14/Treebank.pm]
-implements similar functionality in Perl.
+Lingua::Treebank[http://search.cpan.org/~kahn/Lingua-Treebank/] implements similar functionality in Perl.
 
 = Copyright
 
-Copyright 2006, William Patrick McNeill
+Copyright 2006-2008, William Patrick McNeill
 
 This program is distributed under the GNU General Public License.
 
 = Author
 
 W.P. McNeill mailto:billmcn@u.washington.edu
-

data/examples/penntb-words

@@ -1,7 +1,7 @@
 #!/bin/env ruby
 
 #--
-# Copyright 2006 William Patrick McNeill
+# Copyright 2006-2008 William Patrick McNeill
 #
 # This file is part of Treebank.
 #

data/lib/treebank.rb

@@ -1,4 +1,4 @@
-# Copyright 2006 William Patrick McNeill
+# Copyright 2006-2008 William Patrick McNeill
 #
 # Treebank is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
@@ -14,21 +14,22 @@
 # along with editalign; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
+require "enumerator"
 
 # Treebank is the namespace that contains all tree-related functions.
 module Treebank
 
-  VERSION = "2.1.0"
+  VERSION = "3.0.0"
 
   # An enumerable list of tokens in a string representation of a tree
   #
-  # This class provides a way of enumerating over a source to produce
-  # tokens that can be used in parsing a string representation of a
-  # tree.  The source is an enumerable object whose _each_ function
-  # returns a sequence of String objects, for example a file or a
-  # single String.  Each returned string is delimited by left and
-  # right brackets and whitespace.  The default brackets are '(' and
-  # ')', but different delimiters may be specified in the constructor.
+  # This class provides a way of enumerating over a source to produce tokens
+  # that can be used in parsing a string representation of a tree.  The source
+  # is an enumerable object whose _each_ function returns a sequence of String
+  # objects, for example a file or a single String.  Each returned string is
+  # delimited by left and right brackets and whitespace.  The default brackets
+  # are '(' and ')', but different delimiters may be specified in the
+  # constructor.
   #
   #   Treebank::TokenStream.new('(A (B c) (D))').collect
   #   => ["(", "A", "(", "B", "c", ")", "(", "D", ")", ")"]
@@ -80,8 +81,8 @@ module Treebank
 
   # A parser for string representations of trees.
   #
-  # This class uses a simplified shift-reduce parser to convert a
-  # string into a list of tree structures.
+  # This class uses a simplified shift-reduce parser to convert a string into
+  # a list of tree structures.
   #
   #   Treebank::Parser.new('(A) (B (C) (D))').collect
   #   => [<Treebank::Node A []>, <Treebank::Node B [C D]>]
@@ -95,13 +96,12 @@ module Treebank
   # * children -> node*|word
   # * word -> \w+
   #
-  # Note that the BNF definition of children allows a shortcut in
-  # which the labels of terminal nodes may be specified without
-  # brackets.  So, for example, <tt>(A (B))</tt> and <tt>(A B)</tt>
-  # are equivalent.
+  # Note that the BNF definition of children allows a shortcut in which the
+  # labels of terminal nodes may be specified without brackets.  So, for
+  # example, <tt>(A (B))</tt> and <tt>(A B)</tt> are equivalent.
   #
-  # The trees returned by this class are caller-defined node objects,
-  # where each node has a list of child nodes.
+  # The trees returned by this class are caller-defined node objects, where
+  # each node has a list of child nodes.
   class Parser
     include Enumerable
 
@@ -164,61 +164,13 @@ module Treebank
 
   # A node in a tree
   #
-  # A Node consists of a label, which may be any arbitrary Object, and
-  # a list of children, which are also Node objects.
+  # A Node consists of a label, which may be any arbitrary Object, and a list
+  # of children, which are also Node objects.
   class Node
     include Enumerable
 
-    # Iterates a tree breadth-first
-    class BFSIterator
-      include Enumerable
-
-      # _node_:: The start node of the enumeration
-      # _visit_:: Optional enumeration control procedure
-      #
-      # The optional _visit_ argument can be used to control which
-      # children are visited by this iterator.  If specified, it is
-      # called for every node, and only those nodes returning _true_
-      # will be visited.
-      def initialize(node, visit = nil)
-        @node = node
-        @visit = visit
-      end
-
-      # Enumerate the nodes.
-      def each
-        @agenda = [@node]
-        while node = @agenda.shift
-          yield node
-          children = @visit ? node.find_all {|n| @visit.call(n)} : node.collect
-          recurse(children)
-        end
-      end
-
-      # Function that controls enumeration recursion.
-      #
-      # _children_:: A list of child nodes of the current node
-      #
-      # The only difference between the breadth-first and depth-first
-      # searches is this function.
-      def recurse(children)
-        @agenda += children 
-      end
-    end # BFSIterator
-
-    # Iterates a tree depth-first
-    class DFSIterator < BFSIterator
-
-      # Function that controls enumeration recursion
-      #
-      # _children_:: A list of child nodes of the current node
-      #
-      # The only difference between the breadth-first and depth-first
-      # searches is this function.
-      def recurse(children)
-        @agenda = children + @agenda
-      end
-    end # DFSIterator
+    # The children of this node.
+    attr_reader :children
 
     # This node's label
     attr_accessor :label
@@ -262,15 +214,15 @@ module Treebank
     end
 
     # Returns a string representation of this node and its children over
-    # multiple lines with indenting.  This matches the format used in the Penn
-    # Treebank files.
+    # multiple lines with indenting.  This matches the format used in the {Penn
+    # Treebank}[http://www.cis.upenn.edu/~treebank] files.
     #
     # _indent_:: The number of spaces to indent this node in the output
     # _parent_:: The node's parent
     # _left_sibling_:: The node's left sibling
     #
-    # This algorithm is based on the stringification algorithm in the Stanford
-    # Natural Language Parser.
+    # This algorithm is based on the stringification algorithm in the {Stanford
+    # Natural Language Parser}[http://nlp.stanford.edu/downloads/lex-parser.shtml].
     def multiline_to_s(indent, parent, left_sibling)
       # Insert a new line and indenting before this node as needed.  Stay on
       # the same line if this is the top of the tree, if the parent label is
@@ -299,13 +251,15 @@ module Treebank
       "<#{self.class} #{@label} [#{child_labels.join(' ')}]>"
     end
 
-    # If the other object is a tree and every node label in the
-    # corresponding nodes of the two depth first enumerations match,
-    # the trees are equivalent.
+    # If the other object is a tree and every node label in the corresponding
+    # nodes of the two depth first enumerations match, the trees are
+    # equivalent.
     def ==(other)
       return false if not other.kind_of? self.class
       return true if self.empty? and other.empty?
-      mismatch = self.each_depth_first.zip(other.each_depth_first).find \
+      self_enum = Enumerable::Enumerator.new(self, :each_depth_first)
+      other_enum = Enumerable::Enumerator.new(other, :each_depth_first)
+      mismatch = self_enum.zip(other_enum).find \
       {|self_node, other_node| self_node.nil? or \
         other_node.nil? or \
         self_node.label != other_node.label}
@@ -351,24 +305,6 @@ module Treebank
     def each
       @children.each {|node| yield node}
     end
-    
-    # Enumerate all the nodes beneath this one breadth-first
-    #
-    # _visit_:: Optional enumeration control procedure
-    #
-    # The _visit_ parameter is passed down to the BFSIterator.
-    def each_breadth_first(visit = nil)
-      BFSIterator.new(self, visit)
-    end
-
-    # Enumerate all the nodes beneath this one depth-first
-    #
-    # _visit_:: Optional enumeration control procedure
-    #
-    # The _visit_ parameter is passed down to the DFSIterator.
-    def each_depth_first(visit = nil)
-      DFSIterator.new(self, visit)
-    end
 
     # A leaf node has no children.
     def leaf?
@@ -389,17 +325,160 @@ module Treebank
     #
     # _block_:: An optional block to run on each leaf
     def leaves(&block)
-      leaves = each_depth_first.find_all {|node| node.leaf?}
+      leaves = depth_first_enumerator.find_all {|node| node.leaf?}
       leaves = leaves.collect {|leaf| block.call(leaf)} if not block.nil?
       leaves
     end
 
-    protected :multiline_to_s
+    # Return the child node specified by the coordinate index or nil if the
+    # coordinate is out of range.  An empty argument list returns this node.
+    #
+    # _index_:: A list of integers that indexes the child node
+    #
+    #    t = Treebank::Node.from_s("(A (B b) (C (D d) (E e)))")
+    #    <Treebank::Node A [B C]>
+    #    t[1,0]
+    #    <Treebank::Node D [d]>
+    def [](*index)
+      child = self
+      index.each do |i|
+        child = child.children[i]
+        break if child.nil?
+      end
+      child
+    end
+
+    # Enumerate this node and its children depth-first.
+    #
+    # _indexed_:: Return indexes along with nodes?
+    # _visit_:: Optional enumeration control procedure
+    #
+    #    > t = Treebank::Node.from_s("(A (B b) (C c))")
+    #    > t.each_depth_first() {|n,index| puts n.label}
+    #    A
+    #    B
+    #    b
+    #    C
+    #    c
+    #    > t.each_depth_first(true) {|n,index| puts "#{n.label} #{index.inspect}"}
+    #    A []
+    #    B [0]
+    #    b [0, 0]
+    #    C [1]
+    #    c [1, 0]
+    #
+    # See the each_descendant documentation for more details on the function
+    # arguments.
+    def each_depth_first(indexed = false, visit = nil)
+      each_descendant(indexed, :depth_first, visit) {|node| yield node}
+    end
+
+    # Return an Enumerator[http://www.ruby-doc.org/core/classes/Enumerable/Enumerator.html]
+    # object that enumerates this node and its descendants depth-first.
+    #
+    # See the each_descendant documentation for more details on the function
+    # arguments.
+    def depth_first_enumerator(indexed = false, visit = nil)
+      Enumerable::Enumerator.new(self, :each_depth_first, indexed, visit)
+    end
+
+    # Enumerate this node and its children breadth-first.
+    #
+    # _indexed_:: Return indexes along with nodes?
+    # _visit_:: Optional enumeration control procedure
+    #
+    #    > t = Treebank::Node.from_s("(A (B b) (C c))")
+    #    > t.each_breadth_first() {|n,index| puts n.label}
+    #    A
+    #    B
+    #    C
+    #    b
+    #    c
+    #    > t.each_breadth_first(true) {|n,index| puts "#{n.label} #{index.inspect}"}
+    #    A []
+    #    B [0]
+    #    C [1]
+    #    b [0, 0]
+    #    c [1, 0]
+    #
+    # See the each_descendant documentation for more details on the function
+    # arguments.
+    def each_breadth_first(indexed = false, visit = nil)
+      each_descendant(indexed, :breadth_first, visit) {|node| yield node}
+    end
+
+    # Return an Enumerator[http://www.ruby-doc.org/core/classes/Enumerable/Enumerator.html]
+    # object that enumerates this node and its descendants breadth-first.
+    #
+    # See the each_descendant documentation for more details on the function
+    # arguments.
+    def breadth_first_enumerator(indexed = false, visit = nil)
+      Enumerable::Enumerator.new(self, :each_breadth_first, indexed, visit)
+    end
+
+    # Enumerate the initial node and its childen in the order specified,
+    # yielding either just nodes or nodes and indexes.
+    #
+    # _indexed_:: Return indexes of the nodes?
+    # _order_:: :depth_first or :breadth_first
+    # _visit_:: Optional enumeration control procedure
+    #
+    # If _indexed_ is _true_ this class yields <tt>[node, index]</tt> pairs
+    # where _index_ is the index used by the  [] operator.  Otherwise, it
+    # yields just the nodes.
+    #
+    # The optional _visit_ argument can be used to control which children are
+    # visited by this iterator.  If specified, it is called for every node,
+    # and only those nodes returning _true_ will be visited.
+    def each_descendant(indexed, order, visit)
+      agenda = indexed ? [ [self, []] ] : [self]
+      while item = agenda.shift
+        yield item
+        # If we're enumerating over nodes and their indexes, the agenda items
+        # are (node, index) pairs.  Otherwise they are just nodes.
+        new_items = indexed ? indexed_new_agenda_items(item, visit) :
+                              non_indexed_new_agenda_items(item, visit)
+        # The difference between depth- and breadth-first search orders lies
+        # in the way the agenda is updated.
+        if order == :depth_first
+          agenda = new_items + agenda
+        elsif order == :breadth_first
+          agenda = agenda + new_items
+        else
+          raise "Invalid search order #{order}"
+        end
+      end
+    end
+
+    # Agenda items consist of a tree node and a node index.  Get new agenda
+    # items by recursing into children of the node. Append child index to the
+    # node indexes in the new agenda items.
+    def indexed_new_agenda_items(item, visit)
+      node, index = item
+      new_items = []
+      if visit
+        node.children.each_with_index do |n, i|
+          new_items << [n, index + [i]] if visit.call(n)
+        end
+      else
+        node.children.each_with_index{|n, i| new_items << [n, index + [i]]}
+      end
+      new_items
+    end
+
+    # Agenda items consist of a tree node.  Get new agenda items by recursing
+    # into the children.
+    def non_indexed_new_agenda_items(node, visit)
+      visit ? node.find_all {|n| visit.call(n)} : node.children
+    end
+
+    private :indexed_new_agenda_items, :non_indexed_new_agenda_items
+    protected :multiline_to_s, :each_descendant
 
   end # Node
 
 
-  # A Node in a Tree that can locate its parent.
+  # A Node in a tree that can locate its parent.
   #
   # The ParentedNode adds a pointer back to the parent node to
   # the Node class.
@@ -408,26 +487,6 @@ module Treebank
     # This node's parent
     attr_reader :parent
 
-    # Iterates up a tree
-    class ParentIterator
-      include Enumerable
-
-      # _node_:: The start node of the enumeration
-      def initialize(node)
-        @node = node
-      end
-
-      # Enumerate the ancestor chain.
-      def each
-        node = @node
-        while not node.nil?
-          yield node
-          node = node.parent
-        end
-      end
-
-    end # ParentIterator
-
     # Create a node specifying its parent, its label, and its children's
     # labels.
     #
@@ -460,9 +519,19 @@ module Treebank
       @parent = parent
     end
 
-    # Enumerate the ancestors of this node.
+    # Enumerate this node and its ancestors.
     def each_parent
-      ParentIterator.new(self)
+      node = self
+      while not node.nil?
+        yield node
+        node = node.parent
+      end
+    end
+
+    # Return an Enumerator[http://www.ruby-doc.org/core/classes/Enumerable/Enumerator.html]
+    # object that enumerates this node and its parents.
+    def parent_enumerator
+      Enumerable::Enumerator.new(self, :each_parent)
     end
 
     protected :parent=

data/test/test_treebank.rb

@@ -1,7 +1,7 @@
 #!/bin/env ruby
 
 #--
-# Copyright 2006 William Patrick McNeill
+# Copyright 2006-2008 William Patrick McNeill
 #
 # This file is part of Treebank.
 #
@@ -86,24 +86,20 @@ end
 
 
 class TreeParserTest < Test::Unit::TestCase
-
   include ParseTreeMixin
- 
+
   def setup
     @node_class = Treebank::Node
   end
-
 end
 
 
 class ParentedTreeParserTest < Test::Unit::TestCase
-
   include ParseTreeMixin
- 
+
   def setup
     @node_class = Treebank::ParentedNode
   end
-
 end
 
 
@@ -116,8 +112,8 @@ module NodeTestMixin
     assert_nil t.label, 'Empty tree nil head'
     assert t.empty?, 'Empty empty?'
     assert_equal [], t.collect, 'Empty child list'
-    assert_equal [t], t.each_breadth_first.collect, 'Empty breadth first'
-    assert_equal [t], t.each_depth_first.collect, 'Empty depth first'
+    assert_equal [t], t.breadth_first_enumerator.collect, 'Empty breadth first'
+    assert_equal [t], t.depth_first_enumerator.collect, 'Empty depth first'
   end
 
   # Test a single node tree
@@ -126,8 +122,8 @@ module NodeTestMixin
     assert_equal 'a', t.label, 'Single node label'
     assert !t.empty?, 'Single node not empty?'
     assert_equal [], t.collect, 'Empty child list'
-    assert_equal [t], t.each_breadth_first.collect, 'Single node breadth first'
-    assert_equal [t], t.each_depth_first.collect, 'Single depth first'
+    assert_equal [t], t.breadth_first_enumerator.collect, 'Single node breadth first'
+    assert_equal [t], t.depth_first_enumerator.collect, 'Single depth first'
   end
 
   # Test adding children in the constructor
@@ -168,7 +164,7 @@ module NodeTestMixin
 
   # Read to and from a typical Wall Street Journal treebank string
   def test_wsj_sentence_stringify
-    s = 
+    s =
 "( (S
     (NP-SBJ (CD Two) (VBG leading) (NN constitutional-law) (NNS experts))
     (VP (VBD said)
@@ -191,16 +187,16 @@ module NodeTestMixin
   def test_enumeration
     # Enumerate all children.
     t = @node_class.from_s('(a (b (R) (S) ) (c (T) (U)) )')
-    assert_equal ['a', 'b', 'c', 'R', 'S', 'T', 'U'], t.each_breadth_first.collect {|node| node.label}, 'Full breadth first'
-    assert_equal ['a', 'b', 'R', 'S', 'c', 'T', 'U'], t.each_depth_first.collect {|node| node.label}, 'Full depth first'
+    assert_equal ['a', 'b', 'c', 'R', 'S', 'T', 'U'], t.breadth_first_enumerator.collect {|node| node.label}, 'Full breadth first'
+    assert_equal ['a', 'b', 'R', 'S', 'c', 'T', 'U'], t.depth_first_enumerator.collect {|node| node.label}, 'Full depth first'
     # Enumerate children beneath a node.
     b = t.find {|node| node.label == 'b'}
-    assert_equal ['b', 'R', 'S'], b.each_breadth_first.collect {|node| node.label}, 'Partial breadth first'
-    assert_equal ['b', 'R', 'S'], b.each_depth_first.collect {|node| node.label}, 'Partial depth first'
+    assert_equal ['b', 'R', 'S'], b.breadth_first_enumerator.collect {|node| node.label}, 'Partial breadth first'
+    assert_equal ['b', 'R', 'S'], b.depth_first_enumerator.collect {|node| node.label}, 'Partial depth first'
     # Customize visitation.
     visit = proc{|n| n.label != 'c' and n.label != 'S'}
-    assert_equal ['a', 'b', 'R'], t.each_breadth_first(visit).collect {|node| node.label}, 'Full breadth first'
-    assert_equal ['a', 'b', 'R'], t.each_depth_first(visit).collect {|node| node.label}, 'Full depth first'
+    assert_equal ['a', 'b', 'R'], t.breadth_first_enumerator(false, visit).collect {|node| node.label}, 'Custom breadth first'
+    assert_equal ['a', 'b', 'R'], t.depth_first_enumerator(false, visit).collect {|node| node.label}, 'Custom depth first'
   end
 
   # Tree equivalence
@@ -215,41 +211,64 @@ module NodeTestMixin
     assert_not_equal t1, 'non-tree', 'Tree non-equivalence: not a tree'
   end
 
+  # Test leaves function
   def test_leaves
     t = @node_class.from_s('(a (b c) (d e))')
-    leaves = t.each_depth_first.collect
+    leaves = t.depth_first_enumerator.collect
     c = leaves[2]
     e = leaves[4]
     assert_equal [c, e], t.leaves, 'Tree leaves'
     assert_equal ['c', 'e'], t.leaves {|n| n.label}, 'Tree leaves with block'
   end
+
+  # Test dereferencing children by index
+  def test_child_dereference
+    t = @node_class.from_s("(A (B b) (C (D d) (E e)))")
+    nA, nB, b, nC, nD, d, nE, e = t.depth_first_enumerator.collect
+    assert_equal nA, t[]
+    assert_equal nB, t[0]
+    assert_equal b, t[0,0]
+    assert_equal nil, t[0,1]
+    assert_equal nC, t[1]
+    assert_equal nil, t[2]
+    assert_equal nD, t[1,0]
+    assert_equal d, t[1,0,0]
+    assert_equal nil, t[1,0,1]
+    assert_equal nE, t[1,1]
+    assert_equal nil, t[1,2]
+    assert_equal e, t[1,1,0]
+    assert_equal nil, t[1,1,1]
+  end
+  
+  def test_indexed_enumeration
+    t = @node_class.from_s("(A (B b) (C (D d) (E e)))")
+    assert t.depth_first_enumerator(true).all?{|n,i| n == t[*i]}
+  end
+  
 end
 
 
 class NodeTest < Test::Unit::TestCase
-
   include NodeTestMixin
- 
+
   def setup
     @node_class = Treebank::Node
   end
-
 end
 
 
 class ParentedNodeTest < Test::Unit::TestCase
-
   include NodeTestMixin
- 
+
   def setup
     @node_class = Treebank::ParentedNode
   end
 
   def test_ancestor_enumeration
     t = @node_class.from_s('(a (b (R) (S) ) (c (T) (U)) )')
-    assert_equal [t], t.each_parent.collect, 'Ancestors from head'
-    u = t.each_depth_first.find {|node| node.label == 'U'}
-    assert_equal ['U', 'c', 'a'], u.each_parent.collect {|node| node.label}, 'Ancestors from leaf'
+    assert_equal [t], t.parent_enumerator.collect, 'Ancestors from head'
+    u = t.depth_first_enumerator.find {|node| node.label == 'U'}
+    assert_equal ['U', 'c', 'a'], u.parent_enumerator.collect {|node| node.label}, 'Ancestors from leaf'
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: treebank
 version: !ruby/object:Gem::Version 
-  version: 2.1.0
-date: 2007-12-11 00:00:00 -08:00
+  version: 3.0.0
+date: 2008-04-16 00:00:00 -07:00
 summary: Treebank implements support for ordered n-ary branching tree structures
 require_paths: 
 - lib