jumoku 0.1.3 → 0.2.0

data/lib/jumoku/classes/tree_classes.rb

@@ -1,7 +1,9 @@
 module Jumoku
-  # A generic {RawTreeBuilder RawTree} class you can inherit from.
-  class RawTree; include RawTreeBuilder; end
+  # "Raw" implementations.
+  class RawUndirectedTree; include RawUndirectedTreeBuilder; end
+  class RawDirectedTree;   include RawDirectedTreeBuilder;   end
 
-  # The main tree class to use. Fully-fledged tree structure with user-friendly public API.
-  class Tree;    include TreeBuilder;    end
+  # "Useful" implementations.
+  class Tree;         include TreeBuilder;         end
+  class Arborescence; include ArborescenceBuilder; end
 end

data/lib/jumoku/ext/ext.rb

@@ -42,9 +42,15 @@ class Array
     self.create_pairs.flatten(1)
   end
 
-  def create_branches_list
+  # Create a list of branches object based on an expandable array of nodes.
+  #
+  # TODO: refacto, it's painful having to pass the branch_type
+  #
+  # @param [DirectedBranch, UndirectedBranch] branch_type
+  #
+  def create_branches_list(branch_type)
     branches = []
-    self.expand_branches!.each_by(2) { |pair| branches << Jumoku::Branch.new(pair[0], pair[1]) }
+    self.expand_branches!.each_by(2) { |pair| branches << branch_type.new(pair[0], pair[1]) }
     branches
   end
 end

data/lib/jumoku/raw_tree_node.rb

@@ -1,12 +1,11 @@
 module Jumoku
   module RawTree
-
-    # This module describes a raw tree node.
+    # This module describes RawTree nodes.
+    #
+    # You may also use this module as a mixin to have a class behave
+    # as a RawTree node, while customizing behaviors.
     #
-    # You can include it in a class of your own to make it act
-    # as a raw tree node, while customizing behaviors.
     module Node
-
       # Creates a new node.
       #
       # @param [#to_s, #to_sym] name a valid name, considering the :names_as options
@@ -15,6 +14,7 @@ module Jumoku
       # @param [Array(#to_s)] children an array of children nodes ids
       #
       # @return [OpenObject] the node as an OpenObject instance
+      #
       def create name, data = OpenObject.new, children = []
         @name = name
         @data = data

data/lib/jumoku/support/branch.rb

@@ -1,4 +1,12 @@
 module Jumoku
-  class Branch < Plexus::Edge
+  # Namespacing. Useful for duck typing criteria.
+  module Branch; end
+
+  class UndirectedBranch < Plexus::Edge
+    include Branch
+  end
+
+  class DirectedBranch   < Plexus::Arc
+    include Branch
   end
 end

data/lib/jumoku/support/support.rb

@@ -1,15 +1,8 @@
 module Jumoku
-  # Base error class for the library.
-  class JumokuError < StandardError; end
-
-  # Raised in several circumstances when the basic constraints related
-  # to a tree are not fulfilled (undirected, acyclic, connected).
-
-  class RawTreeError < JumokuError; end
-  # Error related to nodes.
-
-  class RawTreeNodeError < RawTreeError; end
-  # Raised if one attempts to add an already existing branch to a tree.
-
-  class BranchAlreadyExistError < JumokuError; end
+  class JumokuError             < StandardError; end
+  class RawTreeError            < JumokuError;   end
+  class RawTreeNodeError        < RawTreeError;  end
+  class BranchAlreadyExistError < JumokuError;   end
+  class ForbiddenCycle          < JumokuError;   end
+  class UndefinedNode           < JumokuError;   end
 end

data/lib/jumoku/tree_api.rb

@@ -1,8 +1,8 @@
 module Jumoku
-  # This module defines the minimum set of functions required to make a tree that can
-  # use the algorithms defined by this library.
+  # This module defines the minimum set of methods required to build a tree
+  # which can use the algorithms defined in this library.
   #
-  # Each implementation module must implement the following routines:
+  # A module based abiding to the TreeAPI must implement the following routines:
   #
   # * add_node!(n, l = nil) — adds a node to the tree and return the tree; l is an optional label (see Plexus library).
   # * add_branch!(i, j = nil, l = nil) — adds a branch to the tree and return the tree. i can be a {Branch}, or (i,j) a node pair; l is an optional label.
@@ -11,17 +11,17 @@ module Jumoku
   # * nodes — returns an array of all nodes.
   # * terminal_nodes — returns an array of all terminal nodes.
   # * branches — returns an array of all branches.
+  #
   module TreeAPI
-
-    # @raise if the API is not completely implemented
+    # @raise [JumokuError] if the API is not completely implemented
+    #
     def self.included(klass)
       @api_methods ||= [:add_node!, :add_branch!, :remove_node!, :remove_branch!, :nodes, :terminal_nodes, :branches]
       ruby_18 { @api_methods.each { |m| m.to_s } }
 
       @api_methods.each do |meth|
-        raise "Must implement #{meth}" unless klass.instance_methods.include?(meth)
+        raise JumokuError, "Must implement #{meth}" unless klass.instance_methods.include?(meth)
       end
     end
-
   end
 end

data/lib/jumoku/version.rb

@@ -1,6 +1,6 @@
 module Jumoku
   MAJOR = 0
-  MINOR = 1
-  PATCH = 3
+  MINOR = 2
+  PATCH = 0
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/spec/{raw_tree_spec.rb → raw_undirected_tree_spec.rb}

@@ -1,21 +1,8 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-# The RawTree builder implements TreeAPI and ensures the tree
-# is a valid tree as far as Graph Theory is concerned:
-# a tree is an undirected, connected, acyclic graph.
-#
-# Note: these tests may make use of the "root"/"children" terminology.
-# Be aware this has got *no* structural meaning as a tree is, by
-# definition, undirected. Those terms are used only to simplify
-# nodes creation within the tests, so I recall who branched who.
-# For tests about rooted tree, see arborescence_spec.rb
-describe "RawTreeBuilder" do
-  before :each do
-    #class MyTree
-      #include RawTreeBuilder
-    #end
+require 'spec_helper'
 
-    @tree = RawTree.new
+describe RawUndirectedTree do
+  before :each do
+    @tree = RawUndirectedTree.new
   end
 
   describe "#new" do
@@ -23,8 +10,8 @@ describe "RawTreeBuilder" do
       @tree.should_not be_directed
       @tree.should be_acyclic
       @tree.should be_connected
-      # aka @tree.should be_valid, 'll use that from now own
-
+      # aka @tree.should be_valid, which we will use further on
+      @tree.should be_valid
       @tree.nodes.should be_empty
     end
   end
@@ -36,7 +23,7 @@ describe "RawTreeBuilder" do
       it "should grow up as a valid tree when adding its first node" do
         @tree.nodes.size.should == 0
 
-        @tree.add_node! "root"
+        @tree.add_node! "root" # adding a raw string as the first node
         @tree.nodes.size.should == 1
         @tree.nodes.should == ["root"]
       end
@@ -44,33 +31,34 @@ describe "RawTreeBuilder" do
 
     describe "a tree with only one node" do
       before :each do
-        @tree.add_node! "root" # remember, this has no meaning
+        # remember, this 'root' thing retain no particular meaning, it's just a raw string
+        # and I could have written "Joe" instead
+        @tree.add_node! "root"
       end
 
-      it "should raise an error when trying to add a new (disconnected) node" do
+      it "should raise an error when trying to add a new, disconnected node" do
+        # again, I'll use childX for the sake of this specs, as it is easy to
+        # remember, but the node is not really a "child" of the previous node,
+        # it is just connected
         lambda { @tree.add_node! "child1" }.should raise_error
       end
 
-      it "should grow up as a valid tree when adding new (connected) nodes" do
+      it "should grow up as a valid tree when adding new, connected nodes" do
         lambda { @tree.add_node! "child1", "root" }.should_not raise_error
 
         @tree.add_node! "child2", "root"
         @tree.add_node! "grand-child1", "child2"
-        @tree.add_node! Jumoku::Branch.new("grand-child2", "child2")
+        @tree.add_node! Jumoku::UndirectedBranch.new("grand-child2", "child2")
 
         @tree.nodes.size.should == 5
-
-        the_nodes = ["root", "child1", "child2", "grand-child1", "grand-child2"]
-        @tree.nodes.should == the_nodes
-        @tree.topsort.should_not == the_nodes
+        @tree.nodes.should == ["root", "child1", "child2", "grand-child1", "grand-child2"]
 
         @tree.add_node! "grand-grand-child1", "grand-child1"
         @tree.add_node! "child3", "root"
         @tree.add_node! "grand-child3", "child3"
         @tree.add_node! "grand-grand-grand-child", "grand-grand-child1"
-        @tree.should_not be_directed
-        @tree.should be_acyclic
-        @tree.should be_connected
+
+        @tree.should be_valid
       end
 
       it "should raise an error when trying to form a cycle" do
@@ -78,34 +66,35 @@ describe "RawTreeBuilder" do
         @tree.add_node! "child2", "root"
         @tree.add_node! "grand-child", "child1"
 
-        lambda { @tree.add_node! "grand-child", "child2" }.should raise_error RawTreeError
+        lambda { @tree.add_node! "grand-child", "child2" }.should raise_error ForbiddenCycle
 
         @tree.add_node! "grand-grand-child", "grand-child"
-        lambda { @tree.add_node! "grand-grand-child", "child1" }.should raise_error RawTreeError
-        lambda { @tree.add_node! "grand-grand-child", "child2" }.should raise_error RawTreeError
+
+        lambda { @tree.add_node! "grand-grand-child", "child1" }.should raise_error ForbiddenCycle
+        lambda { @tree.add_node! "grand-grand-child", "child2" }.should raise_error ForbiddenCycle
       end
     end
   end
 
   describe "#add_branch!" do
     describe "an empty tree" do
-      it "should allow for the creation of its first two nodes as a branch" do
-        lambda { @tree.add_branch! :first, :branch }.should_not raise_error
-        @tree.nodes.should == [:first, :branch]
+      it "should create a branch and return the updated tree" do
+        @tree.add_branch!(:one, :two).should be_a RawUndirectedTree
         @tree.should be_valid
+        @tree.nodes.should == [:one, :two]
       end
     end
 
-    describe "a tree that's not empty" do
+    describe "a tree containing a single node" do
       before :each do
         @tree.add_node! 1
       end
 
-      it "should not allow for disconnected branch creation" do
+      it "should not allow disconnected branch creation" do
         lambda { @tree.add_branch! 10, 11 }.should raise_error RawTreeError
       end
 
-      it "should grow up as a valid tree when populated with (connected) branches" do
+      it "should grow up as a valid tree when populated with connected branches" do
         @tree.nodes.size.should == 1
 
         @tree.add_branch! 1, 2
@@ -119,7 +108,8 @@ describe "RawTreeBuilder" do
 
         @tree.add_branch! 3, 4
         @tree.add_branch! 2, 5
-        lambda { @tree.add_branch! 5, 5 }.should raise_error RawTreeError # cycle (loop)
+        lambda { @tree.add_branch! 5, 5 }.should raise_error ForbiddenCycle
+        lambda { @tree.add_branch! 1, 5 }.should raise_error ForbiddenCycle
         @tree.add_branch! 4, 3
         @tree.add_branch! 5, 6
         @tree.nodes.size.should == 6
@@ -132,11 +122,11 @@ describe "RawTreeBuilder" do
   describe "#remove_node!" do
     describe "an empty tree" do
       it "should not allow to remove a node since there's none" do
-        lambda { @tree.remove_node! "vapornode" }.should raise_error RawTreeError
+        lambda { @tree.remove_node! "undefinedNode" }.should raise_error UndefinedNode
       end
     end
 
-    describe "a tree that's a single node" do
+    describe "a tree containing a single node" do
       before :each do
         @tree.add_node! :last
       end
@@ -148,12 +138,12 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "a tree that is one sole branch (two nodes)" do
+    describe "a tree containing one branch" do
       before :each do
-        @tree1 = RawTree.new
+        @tree1 = RawUndirectedTree.new
         @tree1.add_node! 1
         @tree1.add_node! 2, 1
-        @tree2 = RawTree.new
+        @tree2 = RawUndirectedTree.new
         @tree2.add_node! 1
         @tree2.add_node! 2, 1
       end
@@ -171,7 +161,7 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "a tree with more than two nodes" do
+    describe "a tree containing several branches" do
       before :each do
         # TODO: DRY this snippet
         # i stands for internal, t for terminal
@@ -189,7 +179,7 @@ describe "RawTreeBuilder" do
         lambda { @tree.remove_node! :t8 }.should_not raise_error
         @tree.nodes.size.should == 7
         @tree.nodes.should_not include :t8
-        lambda { @tree.remove_node! :i3 }.should raise_error RawTreeError
+        lambda { @tree.remove_node! :i3 }.should raise_error UndefinedNode
         @tree.should be_valid
       end
 
@@ -208,7 +198,7 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "an tree that is only one node" do
+    describe "an tree containing one node" do
       before :each do
         @tree.add_node! 1
       end
@@ -218,7 +208,7 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "a tree with more than two nodes" do
+    describe "a tree containing several branches" do
       before :each do
         # TODO: DRY this snippet
         # i stands for internal, t for terminal
@@ -240,7 +230,7 @@ describe "RawTreeBuilder" do
         @tree.has_branch?(:i1, :t8).should be_false
         @tree.should be_valid
 
-        @tree.remove_branch! Branch.new(:i5, :t7)
+        @tree.remove_branch! UndirectedBranch.new(:i5, :t7)
         @tree.has_branch?(:i5, :t7).should be_false
         @tree.should be_valid
       end
@@ -254,8 +244,8 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "a tree with some node" do
-      it "should be aware of its node(s)" do
+    describe "a tree containing several nodes" do
+      it "should be aware of its nodes" do
         @tree.add_node! :solo
         @tree.nodes.should == [:solo]
 
@@ -274,14 +264,14 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "a tree that's a single node" do
+    describe "a tree containing one node" do
       it "should have one terminal node" do
         @tree.add_node! 1
         @tree.terminal_nodes.should == [1]
       end
     end
 
-    describe "a populated tree" do
+    describe "a tree with several branches" do
       before :each do
         @tree.add_node! 1
         @tree.add_node! 2, 1
@@ -305,49 +295,21 @@ describe "RawTreeBuilder" do
       end
     end
 
-    describe "a tree that's one node" do
+    describe "a tree containing one node" do
       it "should not have any branch" do
         @tree.add_node! :solo
         @tree.branches.should be_empty
       end
     end
 
-    describe "a tree that's one branch (two nodes)" do
+    describe "a tree containing one branch" do
       it "should have one branch only (undirected)" do
         @tree.add_node! :one
         @tree.add_node! :two, :one
         @tree.branches.size.should == 1
-        @tree.branches.first.class.should == Plexus::Edge # the Jumoku::Branch class is just
-                                                          # a lazy wrapper of it
-        @tree.should be_valid
-      end
-    end
-
-    describe "a tree with n nodes" do
-      before :each do
-        # TODO: DRY this as random_tree(n = 10)
-        @n = rand(50) # number of nodes
-        @tree.add_node! @n
-        @old_node = @n
-
-        (@n - 1).times do
-          begin
-            @new_node = rand(100)
-            @tree.add_node!(@new_node, @old_node)
-          rescue RawTreeError
-            retry # cycle detected!
-          end
-          @old_node = @new_node
-        end
-      end
-
-      it "should have n - 1 branches" do
-        @tree.nodes.size.should == @n
-        @tree.branches.size.should == @n - 1
+        @tree.branches.first.class.should == Plexus::Edge
         @tree.should be_valid
       end
     end
   end
-
-  # TODO: add a final test which sums it up
 end

data/spec/tree_spec.rb

@@ -1,20 +1,8 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-# The Tree builder extends the core functionalities provided
-# by RawTreeBuilder.
-#
-# Note: these tests may make use of the "root"/"children" terminology.
-# Be aware this has got *no* structural meaning as a tree is, by
-# definition, undirected. Those terms are used only to simplify
-# nodes creation within the tests, so I recall who branched who.
-# For tests about rooted tree, see arborescence_spec.rb
-describe "TreeBuilder" do
-  before :each do
-    class MyTree
-      include TreeBuilder
-    end
+require 'spec_helper'
 
-    @tree = MyTree.new
+describe Tree do
+  before :each do
+    @tree = Tree.new
   end
 
   describe "#new" do
@@ -24,15 +12,15 @@ describe "TreeBuilder" do
     end
   end
 
-  ## Core API is tested in raw_tree_spec.rb.
-  ## The following tests focus on TreeBuilder additional methods.
+  ## The core TreeAPI is tested in raw_tree_spec.rb.
+  ## The following tests focus on methods added by TreeBuilder.
 
   describe "#add_node" do
     describe "an empty tree" do
       it "should create a new, valid tree with a single node when its first node is added" do
         @tree.add_node 1
-        @tree.should be_empty
-
+        @tree.should be_empty # the original tree is not modified
+        # a brand new tree is created instead, extending the original one
         new_tree = @tree.add_node 1
         new_tree.nodes.should == [1]
         new_tree.should be_valid
@@ -70,7 +58,7 @@ describe "TreeBuilder" do
       end
     end
 
-    describe "a populate" do
+    describe "a populated tree" do
       before :each do
         @tree.add_branch! 1, 2
         @tree.add_branch! 2, 3
@@ -97,7 +85,7 @@ describe "TreeBuilder" do
       end
     end
 
-    describe "a tree that's one node only" do
+    describe "a tree containing one node" do
       before :each do
         @tree.add_node! 1
       end
@@ -154,11 +142,11 @@ describe "TreeBuilder" do
         @tree.nodes.should == [1, 2, 3, 4]
         @tree.should be_valid
 
-        @tree.add_nodes! Branch.new(5, 2)
+        @tree.add_nodes! UndirectedBranch.new(5, 2)
         @tree.nodes.should == [1, 2, 3, 4, 5]
         @tree.should be_valid
 
-        @tree.add_nodes! 3,4, 1,10, Branch.new(10, 11), -1,1
+        @tree.add_nodes! 3,4, 1,10, UndirectedBranch.new(10, 11), -1,1
         @tree.nodes.size.should == 8
         @tree.should be_valid
 
@@ -181,12 +169,12 @@ describe "TreeBuilder" do
         new_tree.nodes.should == [1, 2, 3, 4]
         new_tree.should be_valid
 
-        new_tree = @tree.add_nodes Branch.new(4, 5)
+        new_tree = @tree.add_nodes UndirectedBranch.new(4, 5)
         @tree.should be_empty
         new_tree.nodes.should == [4, 5]
         new_tree.should be_valid
 
-        new_tree = @tree.add_nodes 3,4, 4,10, Branch.new(10, 11), -1,3
+        new_tree = @tree.add_nodes 3,4, 4,10, UndirectedBranch.new(10, 11), -1,3
         @tree.should be_empty
         new_tree.nodes.size.should == 5
         new_tree.should be_valid
@@ -204,11 +192,11 @@ describe "TreeBuilder" do
   describe "#add_branches!" do
     describe "an empty tree" do
       it "should allow for adding its first branches" do
-        @tree.add_branches! Branch.new(1, 2), 1,3, 3,4
+        @tree.add_branches! UndirectedBranch.new(1, 2), 1,3, 3,4
         @tree.nodes.should == [1, 2, 3, 4]
         @tree.should be_valid
 
-        branch = Branch.new(1, 4)
+        branch = UndirectedBranch.new(1, 4)
         lambda { @tree.add_branches! branch }.should raise_error, RawTreeError
       end
     end
@@ -223,11 +211,11 @@ describe "TreeBuilder" do
         @tree.nodes.should == [1, 2, 3]
         @tree.should be_valid
 
-        @tree.add_branches! Branch.new(0,1), 3,4, Branch.new(4,5)
+        @tree.add_branches! UndirectedBranch.new(0,1), 3,4, UndirectedBranch.new(4,5)
         [0..5].all? { |n| @tree.nodes.include? n } and @tree.nodes.size.should == 5
         @tree.should be_valid
 
-        lambda { @tree.add_branches! Branch.new(2, 5) }.should raise_error, RawTreeError
+        lambda { @tree.add_branches! UndirectedBranch.new(2, 5) }.should raise_error, RawTreeError
       end
     end
   end
@@ -235,7 +223,7 @@ describe "TreeBuilder" do
   describe "add_branches" do
     describe "an empty tree" do
       it "should create a new, valid tree populated with its first branches" do
-        b1, b2, b3 = Branch.new(1, 2), Branch.new(2, 3), Branch.new(3, 4)
+        b1, b2, b3 = UndirectedBranch.new(1, 2), UndirectedBranch.new(2, 3), UndirectedBranch.new(3, 4)
         new_tree = @tree.add_branches b1, b2, b3
         @tree.should be_empty
         new_tree.nodes.should == [1, 2, 3, 4]
@@ -251,13 +239,13 @@ describe "TreeBuilder" do
       end
 
       it "should create a new, valid tree extended with its new branches" do
-        new_tree = @tree.add_branches 4, :five, Branch.new(:five, "six")
+        new_tree = @tree.add_branches 4, :five, UndirectedBranch.new(:five, "six")
         @tree.nodes.should == (1..4).to_a
         new_tree.nodes.should == [1, 2, 3, 4, :five, "six"]
         new_tree.should be_valid
 
         lambda { @tree.add_branches 10, 11 }.should   raise_error, RawTreeError
-        lambda { @tree.add_branches Branch.new 1,4 }.should     raise_error, RawTreeError
+        lambda { @tree.add_branches UndirectedBranch.new 1,4 }.should     raise_error, RawTreeError
       end
     end
   end
@@ -324,7 +312,7 @@ describe "TreeBuilder" do
   describe "#remove_branches!" do
     describe "an empty tree" do
       it "should not allow for removing branches" do
-        lambda { @tree.remove_branches Branch.new(:foo, :bar), 1,2 }.should raise_error, RawTreeError
+        lambda { @tree.remove_branches UndirectedBranch.new(:foo, :bar), 1,2 }.should raise_error, RawTreeError
       end
     end
 
@@ -344,11 +332,11 @@ describe "TreeBuilder" do
       end
 
       it "should allow for removing branches until it has no more branches or a sole node" do
-        @tree.remove_branches! 1,2, Branch.new(2,3), 3,4
+        @tree.remove_branches! 1,2, UndirectedBranch.new(2,3), 3,4
         @tree.should be_empty
         @tree.should be_valid
 
-        lambda { @tree.remove_branches! Branch.new(:foo, :bar), Branch.new(1, 2) }.should raise_error, RawTreeError
+        lambda { @tree.remove_branches! UndirectedBranch.new(:foo, :bar), UndirectedBranch.new(1, 2) }.should raise_error, RawTreeError
       end
     end
   end
@@ -356,7 +344,7 @@ describe "TreeBuilder" do
   describe "#remove_branches" do
     describe "an empty tree" do
       it "should not allow for removing branches" do
-        lambda { @tree.remove_branches :foo, :bar, Branch.new(1, 2) }.should raise_error, RawTreeError
+        lambda { @tree.remove_branches :foo, :bar, UndirectedBranch.new(1, 2) }.should raise_error, RawTreeError
       end
     end
 
@@ -376,12 +364,12 @@ describe "TreeBuilder" do
       end
 
       it "should allow for removing branches until it has no more branches or a sole node, creating a new, valid tree" do
-        new_tree = @tree.remove_branches 1,2, Branch.new(2,3), 3,4
+        new_tree = @tree.remove_branches 1,2, UndirectedBranch.new(2,3), 3,4
         @tree.nodes.should == [1, 2, 3, 4]
         new_tree.should be_empty
         new_tree.should be_valid
 
-        lambda { @tree.remove_branches Branch.new(:foo, :bar), Branch.new(1, 2) }.should raise_error, RawTreeError
+        lambda { @tree.remove_branches UndirectedBranch.new(:foo, :bar), UndirectedBranch.new(1, 2) }.should raise_error, RawTreeError
       end
     end
   end
@@ -527,12 +515,12 @@ describe "TreeBuilder" do
   describe "#add_consecutive_nodes!" do
     describe "a tree" do
       it "should grow as a valid, populated tree if all specified nodes define a valid tree structure" do
-        @tree.add_consecutive_nodes!(1, 2, 3, :four, Branch.new(:foo, "bar"))
-        @tree.has_branches?(1,2, 2,3, Branch.new(3, :four), :four,:foo, :foo,"bar").should be_true # each specified branch exist
-        @tree.has_branches?(1,2, 2,3, Branch.new(3, :four), :four,:foo).should be_true # each specified branch exist
-        @tree.has_branches_among?(1,2, 2,3, Branch.new(3, :four), :four,:foo).should be_false # do not list every existing branch
-        @tree.has_branches_among?(1,2, 2,3, Branch.new(3, :four), :four,:foo, :foo,"bar").should be_true # list all existing branches
-        @tree.has_branches_among?(1,2, 2,3, Branch.new(3, :four), :four,:foo, :foo,"bar", Array.new, "NIL").should be_true # list all existing branches
+        @tree.add_consecutive_nodes!(1, 2, 3, :four, UndirectedBranch.new(:foo, "bar"))
+        @tree.has_branches?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo, :foo,"bar").should be_true # each specified branch exist
+        @tree.has_branches?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo).should be_true # each specified branch exist
+        @tree.has_branches_among?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo).should be_false # do not list every existing branch
+        @tree.has_branches_among?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo, :foo,"bar").should be_true # list all existing branches
+        @tree.has_branches_among?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo, :foo,"bar", Array.new, "NIL").should be_true # list all existing branches
         @tree.should be_valid
       end
     end
@@ -541,10 +529,10 @@ describe "TreeBuilder" do
   describe "#add_consecutive_nodes" do
     describe "a tree" do
       it "should create a new, valid, populated tree if all specified nodes define a valid tree structure" do
-        new_tree = @tree.add_consecutive_nodes(1, 2, 3, :four, Branch.new(:foo, "bar"))
+        new_tree = @tree.add_consecutive_nodes(1, 2, 3, :four, UndirectedBranch.new(:foo, "bar"))
         @tree.should be_empty
-        new_tree.has_branches?(1,2, 2,3, Branch.new(3, :four), :four,:foo, :foo,"bar").should be_true
-        new_tree.has_branches?(1,2, 2,3, Branch.new(3, :four), :four,:foo).should be_true
+        new_tree.has_branches?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo, :foo,"bar").should be_true
+        new_tree.has_branches?(1,2, 2,3, UndirectedBranch.new(3, :four), :four,:foo).should be_true
         new_tree.should be_valid
       end
     end