treebank 1.0.0

data/README

@@ -0,0 +1,59 @@
+= Tree Module
+
+This module supports the creation, search, manipulation, and
+serialization of tree structures.
+
+Trees are implemented with 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.
+
+   irb(main):001:0> require 'treebank'
+   => true
+   irb(main):002:0> p = Treebank::Node.new('parent')
+   => <Treebank::Node parent []>
+   irb(main):003:0> p.create_child!('child1')
+   => <Treebank::Node child1 []>
+   irb(main):004:0> p.create_child!('child2')
+   => <Treebank::Node child2 []>
+
+Node has a subclass 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.
+
+   irb(main):005:0> puts p
+   (parent (child1) (child2))
+   => nil
+
+Bracketed tree strings can be used to create Node trees.
+
+   irb(main):006:0> t = Treebank::Node.new.from_s('(parent (child1) (child2))')
+   => <Treebank::Node parent [child1 child2]>
+   irb(main):007:0> puts t
+   (parent (child1) (child2))
+   => nil
+
+The bracketed tree format is the one used by the Penn
+Treebank[http://www.cis.upenn.edu/~treebank/] Project to annonate
+linguistic structure.
+
+= History
+
+* 1-0-0 ... First release
+
+= See Also
+
+Lingua::Treebank[http://search.cpan.org/~kahn/Lingua-Treebank-0.14/Treebank.pm]
+implements similar functionality in Perl.
+
+= Copyright
+
+Copyright 2006, 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

@@ -0,0 +1,49 @@
+#!/bin/env ruby
+
+#--
+# Copyright 2006 William Patrick McNeill
+#
+# This file is part of Treebank.
+#
+# Treebank is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Treebank is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+#++
+
+# Print all the text in Penn Treebank parse files.
+
+require 'treebank'
+
+# A Penn Treebank File
+#
+# This class omits any comment lines when enumerating the lines in the
+# file.
+class TreebankFile < File
+  def each
+    super do |line|
+      line.gsub!(/\*x.*/, '')
+      yield line if not line.empty?
+    end
+  end
+end
+
+# Enumerate all the file names specified on the command line, opening
+# each one and printing the strings in the trees it contains.
+ARGV.each do |filename|
+  TreebankFile.open(filename) do |file|
+    Treebank::Parser.new(file).each do |tree|
+      puts tree.leaves {|leaf| leaf.label}.join(' ')
+    end
+  end
+end

data/lib/treebank.rb

@@ -0,0 +1,446 @@
+# Copyright 2006 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Treebank is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+# Treebank is the namespace that contains all tree-related functions.
+module Treebank
+
+  # 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.
+  #
+  #   Treebank::TokenStream.new('(A (B c) (D))').collect
+  #   => ["(", "A", "(", "B", "c", ")", "(", "D", ")", ")"]
+  class TokenStream
+    include Enumerable
+
+    # The left delimiter
+    attr_reader :left
+
+    # The right delimiter
+    attr_reader :right
+
+    # Constructor
+    #
+    # * source ... the string stream to tokenize
+    # * left ... left bracket symbol
+    # * right ... right bracket symbol
+    def initialize(source, left = '(', right = ')')
+      @source = source
+      @left = left
+      @right = right
+      # Escape the '[' and ']' characters in the character class
+      # regular expression.
+      cc_left = (left == '[') ? "\\#{left}" : left
+      cc_right = (right == ']') ? "\\#{right}" : right
+      # Delimit by left and right brackets, e.g. /\(|\)|[^()]/
+      @s_regex = Regexp.new("\\#{@left}|\\#{@right}|[^#{cc_left}#{cc_right}]+")
+    end
+
+    # Enumerate the tokens in the source
+    def each
+      @source.each do |string|
+        tokenize_string(string) {|token| yield token}
+      end
+    end
+
+    # Tokenize the source string
+    #
+    # * string ... the string to tokenize
+    def tokenize_string(string)
+      string.scan(@s_regex) do |bracket_delimited|
+        bracket_delimited.split.each {|token| yield token}
+      end
+    end
+
+    protected :tokenize_string
+
+  end # TokenStream
+
+  # 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.
+  #
+  #   Treebank::Parser.new('(A) (B (C) (D))').collect
+  #   => [<Treebank::Node A []>, <Treebank::Node B [C D]>]
+  #
+  # The string representation of a list of trees has the following BNF
+  # definition
+  #
+  # * trees -> node*
+  # * node -> (label? children)
+  # * label -> word
+  # * 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.
+  #
+  # The trees returned by this class are caller-defined node objects,
+  # where each node has a list of child nodes.
+  class Parser
+    include Enumerable
+
+    # Constructor
+    #
+    # * tokens ... stream of tokens to be converted into trees
+    # * node_class ... class of node to create
+    #
+    # If _tokens_ is not a kind of TokenStream object it will be used
+    # as the source stream of one.
+    def initialize(tokens, node_class = Node)
+      tokens = TokenStream.new(tokens) if not tokens.kind_of? TokenStream
+      @tokens = tokens
+      @node_class = node_class
+    end
+
+    # Enumerate the tokens yielding trees
+    def each # :yields: tree
+      parse = []
+      @tokens.each do |token|
+        case token
+        when @tokens.left
+          parse << :left
+        when @tokens.right
+          # Reduce the end of the parse stack.
+          left_index = parse.rindex(:left)
+          raise "Extra #{@tokens.right}" if left_index.nil?
+          parse[left_index..-1] = reduce(parse[left_index+1..-1])
+          # If the reduced stack consists of a single node, it must be
+          # a complete tree.
+          yield parse.pop if parse.length == 1
+        else
+          parse << token
+        end # case
+      end # do
+      raise "Extra #{@tokens.left}: #{parse}" if not parse.empty?
+    end
+
+    # Convert the end of the parse list into a single node
+    #
+    # * node_parse ... a list of labels and nodes
+    def reduce(node_parse)
+      node = @node_class.new
+      # The first item in the list may be a label.
+      if node_parse.first.class == String
+        node.label = node_parse.shift
+        # Special case: terminals without brackets, e.g. '(V ran)'
+        if node_parse.length == 1 and node_parse.last.class == String
+          node.create_child!(node_parse.last)
+          return node
+        end
+      end
+      # The remaining items are child nodes.
+      node_parse.each {|child| node.attach_child!(child)}
+      node
+    end
+
+    protected :reduce
+
+  end # Parser
+
+
+  # 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.
+  class Node
+    include Enumerable
+
+    # Iterates a tree breadth-first
+    class BFSIterator
+      include Enumerable
+
+      # Constructor
+      #
+      # * 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
+
+    # This node's label
+    attr_accessor :label
+
+    # Constructor
+    #
+    # * label ... the label of this node
+    # * child_labels ... list of labels for children of this node
+    def initialize(label = nil, child_labels = [])
+      @label = label
+      @children = []
+      child_labels.each {|label| create_child!(label)}
+    end
+
+    # Read the tree from a bracketed string
+    #
+    # * s ... bracketed string
+    # * left ... left bracket symbol
+    # * right ... right bracket symbol
+    #
+    # This function uses a Treebank::Parser object to create the tree from
+    # _s_.  This raises an error if this node is not empty.
+    def from_s(s, left = '(', right = ')')
+      raise 'This node is not empty.' if not self.empty?
+      nodes = Parser.new(TokenStream.new(s, left, right), self.class).collect
+      raise "#{s} defines multiple trees" if nodes.length != 1
+      @label = nodes.first.label
+      @children = nodes.first.collect
+      self
+    end
+
+    # Stringify
+    #
+    # This writes to a bracketed string representation that can be
+    # read by the Parser object.
+    def to_s
+      space = leaf? ? '':' '
+      "(#{label}#{space}#{@children.join(' ')})"
+    end
+
+    # Interactive stringification
+    def inspect
+      child_labels = @children.collect {|n| n.label}
+      "<#{self.class} #{@label} [#{child_labels.join(' ')}]>"
+    end
+
+    # Tree equivalence operator
+    #
+    # 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_node, other_node| self_node.nil? or \
+        other_node.nil? or \
+        self_node.label != other_node.label}
+      mismatch.nil?
+    end
+
+    # Create a new node and add it as a child of this node
+    #
+    # * label ... the label of a node to create
+    # * index ... optional insertion index
+    #
+    # If _index_ is not specified, the node is added to the end of the
+    # child list.
+    #
+    # This function returns the added Node object.
+    def create_child!(label, index = nil)
+      attach_child!(self.class.new(label), index)
+    end
+
+    # Attach an existing node as the child of this node
+    #
+    # * node ... the node to add
+    # * index ... optional insertion index
+    #
+    # _node_ must be the same type as this node.
+    #
+    # If _index_ is not specified, the node is added to the end of the
+    # child list.
+    #
+    # This function returns the added Node object.
+    def attach_child!(node, index = nil)
+      raise "#{node} is not class #{self.class}" if node.class != self.class
+      if index.nil?
+        @children << node
+      else
+        @children[index, 0] = node
+      end
+      node
+    end
+
+    # Detach a child node
+    #
+    # * node ... the node to detach
+    #
+    # This removes the specfied node from this node's child list.
+    def detach_child!(node)
+      raise "#{node} is not a child of #{self}" if @children.delete(node).nil?
+    end
+
+    # Enumerate the children of this node.
+    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
+
+    # Is this a leaf node?
+    def leaf?
+      @children.empty?
+    end
+
+    # Is this node empty?
+    def empty?
+      @label.nil? and @children.empty?
+    end
+
+    # All the leaf nodes beneath this node
+    #
+    # * block ... an optional block to run on each leaf
+    def leaves(&block)
+      leaves = each_depth_first.find_all {|node| node.leaf?}
+      leaves = leaves.collect {|leaf| block.call(leaf)} if not block.nil?
+      leaves
+    end
+
+  end # Node
+
+
+  # A Node in a Tree that can locate its parent
+  #
+  # The ParentedNode adds a pointer back to the parent node to
+  # the Node class.
+  class ParentedNode < Node
+
+    # This node's parent
+    attr_reader :parent
+
+    # Iterates up a tree
+    class ParentIterator
+      include Enumerable
+
+      # Constructor
+      #
+      # * 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
+
+    # Constructor
+    #
+    # * label ... the label of this node
+    # * child_labels ... list of labels for children of this node
+    # * parent ... the parent of this node
+    def initialize(label = nil, child_labels = [], parent = nil)
+      super(label, child_labels)
+      @parent = parent
+    end
+
+    # See Treebank::Node.attach_child!
+    def attach_child!(node, index = nil)
+      child = super(node, index)
+      child.parent = self
+      child
+    end
+
+    # See Treebank::Node.detach_child!
+    def detach_child!(node)
+      super(node)
+      node.parent = nil
+    end
+
+    # Set the parent of this node
+    #
+    # * parent ... the parent node
+    #
+    # This is a protected utility function.  It does not change the
+    # child list of _parent_.
+    def parent=(parent)
+      @parent = parent
+    end
+
+    # Enumerate the ancestors of this node
+    def each_parent
+      ParentIterator.new(self)
+    end
+
+    protected :parent=
+
+  end # ParentedNode
+
+end

data/test/test_treebank.rb

@@ -0,0 +1,238 @@
+#!/bin/env ruby
+
+#--
+# Copyright 2006 William Patrick McNeill
+#
+# This file is part of Treebank.
+#
+# Treebank is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Treebank is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+#++
+
+# Test cases for the Treebank module
+
+require 'test/unit'
+require 'treebank'
+
+class TokenStreamTest < Test::Unit::TestCase
+  def test_basic_token_stream
+    t = Treebank::TokenStream.new('(A (B c) (D))')
+    assert_kind_of Treebank::TokenStream, t
+    assert_equal '(', t.left
+    assert_equal ')', t.right
+    assert_equal ['(', 'A', '(', 'B', 'c', ')', '(', 'D', ')', ')'], t.collect
+  end
+
+  def test_non_alphanum_token_stream
+    t = Treebank::TokenStream.new('(A!Node (B!Node .) (14))')
+    assert_kind_of Treebank::TokenStream, t
+    assert_equal '(', t.left
+    assert_equal ')', t.right
+    assert_equal ['(', 'A!Node', '(', 'B!Node', '.', ')', '(', '14', ')', ')'], t.collect
+  end
+
+  def test_different_delimiter
+    t = Treebank::TokenStream.new('<A <B c> <D>>', '<', '>')
+    assert_kind_of Treebank::TokenStream, t
+    assert_equal '<', t.left
+    assert_equal '>', t.right
+    assert_equal ['<', 'A', '<', 'B', 'c', '>', '<', 'D', '>', '>'], t.collect
+  end
+
+  def test_bracket_delimiter
+    t = Treebank::TokenStream.new('[A [B c] [D]]', '[', ']')
+    assert_kind_of Treebank::TokenStream, t
+    assert_equal '[', t.left
+    assert_equal ']', t.right
+    assert_equal ['[', 'A', '[', 'B', 'c', ']', '[', 'D', ']', ']'], t.collect
+  end
+
+end
+
+
+module ParseTreeMixin
+
+  # Parse tree string
+  def test_tree_parse
+    p = Treebank::Parser.new(Treebank::TokenStream.new('(A) (B)'), @node_class)
+    trees = p.collect
+    assert_equal [@node_class.new.from_s('(A)'), @node_class.new.from_s('(B)')], trees
+    assert_kind_of @node_class, trees[0]
+    assert_kind_of @node_class, trees[1]
+    t = Treebank::Parser.new(Treebank::TokenStream.new('(A (B) (C))'), @node_class).collect.first
+    assert_equal t.label, 'A'
+    assert_equal t.collect.first.label, 'B'
+    assert_equal t.collect.last.label, 'C'
+    assert_equal [@node_class.new], Treebank::Parser.new(Treebank::TokenStream.new('()'), @node_class).collect
+  end
+
+  def test_string_in_constructor
+    assert_equal [@node_class.new.from_s('(A)'), @node_class.new.from_s('(B)')], Treebank::Parser.new('(A) (B)', @node_class).collect
+  end
+
+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
+
+
+module NodeTestMixin
+
+  # Empty tree
+  def test_empty_tree
+    t = @node_class.new
+    assert_kind_of @node_class, t, 'Empty tree type'
+    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'
+  end
+
+  # Test a single node tree
+  def test_single_node_tree
+    t = @node_class.new('a')
+    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'
+  end
+
+  # Test adding children in the constructor
+  def test_constructor_children
+    t = @node_class.new('a', ['b', 'c', 'd'])
+    assert_equal @node_class.new.from_s('(a (b) (c) (d) )'), t, 'Children in constructor'
+  end
+
+  # Add children
+  def test_add_children
+    # Add a child of the head node.
+    a = @node_class.new('a')
+    b = a.create_child!('b')
+    assert_kind_of @node_class, b, 'create_child! return value type'
+    assert_equal 'b', b.label, 'create_child! return value label'
+    assert_equal a.collect, [b], 'a children'
+    assert_equal b.collect, [], 'b children'
+    assert !a.empty?, 'create_child! not empty?'
+    a = @node_class.new('a', ['b', 'c', 'd'])
+    a.create_child!('z', 0)
+    assert_equal ['z', 'b', 'c', 'd'], a.collect {|n| n.label}
+    a.create_child!('x', 2)
+    assert_equal ['z', 'b', 'x', 'c', 'd'], a.collect {|n| n.label}
+  end
+
+  # Read from/to a string
+  def test_stringify
+    s = '(S (NP (D (the)) (N (boy))) (VP (V (ran))))'
+    multiline_s = \
+'(S 
+     (NP 
+        (D (the))
+        (N (boy)))
+     (VP
+        (V (ran))))'
+    t = @node_class.new.from_s(s)
+    assert_kind_of @node_class, t, 'from_s'
+    assert_equal s, "#{t}", 'to_s'
+    m = @node_class.new.from_s(multiline_s)
+    assert_equal t, m, 'Single-/multi-line equal'
+  end
+
+  # Simple enumeration
+  def test_enumeration
+    # Enumerate all children.
+    t = @node_class.new.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'
+    # 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'
+    # 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'
+  end
+
+  # Tree equivalence
+  def test_equivalence
+    t1 = @node_class.new.from_s('(a (b (R) (S) ) (c (T) (U)) )')
+    t2 = @node_class.new.from_s('(a (b (R) (S) ) (c (T) (U)) )')
+    s1 = @node_class.new.from_s('(a (b (R) (S) ) (c (T) ) )')
+    s2 = @node_class.new.from_s('(a (c (R) (S) ) (b (T) (U) ) )')
+    assert_equal t1, t2, 'Tree equivalence'
+    assert_not_equal t1, s1, 'Tree non-equivalence: different terminals'
+    assert_not_equal t1, s2, 'Tree non-equivalence: reversed non-terminal labels'
+    assert_not_equal t1, 'non-tree', 'Tree non-equivalence: not a tree'
+  end
+
+  def test_leaves
+    t = @node_class.new.from_s('(a (b c) (d e))')
+    leaves = t.each_depth_first.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
+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.new.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'
+  end
+
+end

metadata

@@ -0,0 +1,61 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: treebank
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2006-06-08 00:00:00 -07:00
+summary: Treebank implements support for ordered n-ary branching tree structures
+require_paths: 
+- lib
+email: billmcn@gmail.com
+homepage: http://rubyforge.org/projects/treebank
+rubyforge_project: 
+description: This module implements ordered n-ary branching tree structures.  It includes support for breadth- and depth- first iteration, and serialization to and from a bracketed tree string.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- W.P. McNeill
+files: 
+- test/test_treebank.rb
+- lib/treebank.rb
+- examples/penntb-words
+- README
+test_files: 
+- test/test_treebank.rb
+rdoc_options: 
+- --title
+- Treebank -- Ruby Tree
+- --main
+- README
+- --line-numbers
+- --inline-source
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fsa
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: