rubytree 0.9.4 → 0.9.5pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eef38e74f8b74480e08fbe55be05ae1ce1fd3f18
-  data.tar.gz: ef1aa978ef83d54e4645a8d3cf5d7fc8fa77b547
+  metadata.gz: 93e0fdbd846f7fada7cd50d0e0ab414834f464dc
+  data.tar.gz: 3e70254cbc163580c3b7e40a497292a8e4d15128
 SHA512:
-  metadata.gz: 1f4aef945397df03a11cc80ec577b00cc029c48974f005977782a60b8b6b0ac13e15555eab225b829f4170c6755e1f8a62b19e832cfc04163bdedbdbd2e06719
-  data.tar.gz: cc6a69fe2a88e2a2cbf67982f1547bfd0386efa2e93058de001be9cdacd14c3a7add097b72938880b78577b3e5f245df13b9e697a45cc7db302475d9ffec9e67
+  metadata.gz: 957a7cdbb556f41f9c599f82483f058e72cf432837a73bf71d1c86a26c0a3f1c2e1d3a8706a419d1c057b46920215ba2b9046bd83f10720efe46f3bb29bb2486
+  data.tar.gz: e74fb819ae9e568a1d5409f98ae89c18e0bd85f98300df7cc272dbfa9a7c4f01aa1d9474a8bc7fbb0f334019e3b045e2313621f16b2276aaf206bec24f241c6e

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    rubytree (0.9.4)
+    rubytree (0.9.5pre)
       json (~> 1.8)
       structured_warnings (~> 0.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coveralls (0.7.0)
+    coveralls (0.7.1)
       multi_json (~> 1.3)
       rest-client
       simplecov (>= 0.7)
@@ -16,27 +16,29 @@ GEM
       thor
     docile (1.1.5)
     json (1.8.1)
-    mime-types (2.3)
+    mime-types (2.4.3)
     multi_json (1.10.1)
+    netrc (0.8.0)
     rake (10.3.2)
-    rdoc (4.1.1)
+    rdoc (4.1.2)
       json (~> 1.4)
-    rest-client (1.6.7)
-      mime-types (>= 1.16)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
     rtags (0.98)
     rtagstask (0.0.4)
       rtags (> 0.0.0)
-    simplecov (0.8.2)
+    simplecov (0.9.1)
       docile (~> 1.1.0)
-      multi_json
+      multi_json (~> 1.0)
       simplecov-html (~> 0.8.0)
     simplecov-html (0.8.0)
     structured_warnings (0.1.4)
     term-ansicolor (1.3.0)
       tins (~> 1.0)
     thor (0.19.1)
-    tins (1.3.0)
-    yard (0.8.7.4)
+    tins (1.3.3)
+    yard (0.8.7.6)
 
 PLATFORMS
   ruby

data/History.rdoc

@@ -2,6 +2,18 @@
 
 = History of Changes
 
+=== 0.9.5pre / 2014-11-01
+
+* Fixed {issue 13}[https://github.com/evolve75/RubyTree/issues/13] with the
+  patch provided by {Jen Hamon}[http://www.github.com/jhamon].
+
+* Fixed a bug in {Tree::TreeNode#print_tree} with the patch provided by
+  {https://github.com/packetmonkey Evan Sharp}.
+
+* Fixed {issue 31}[https://github.com/evolve75/RubyTree/issues/31], which was
+  causing incorrect behavior n {Tree::TreeNode#postordered_each} and
+  {Tree::TreeNode#breadth_each} methods when a block was not provided.
+
 === 0.9.4 / 2014-07-04
 
 * Changed all references to {http://rubyforge.org}.

data/README.md

@@ -210,6 +210,7 @@ A big thanks to the following contributors for helping improve **RubyTree**:
    duplicate node names in the tree (globally unique names).
 6. [Paul de Courcel](https://github.com/pdecourcel) for adding the
    `postordered_each` method.
+7. [Jen Hamon](http://www.github.com/jhamon) for adding the `from_hash` method.
 
 ## LICENSE: ##
 

data/TAGS

@@ -0,0 +1,242 @@
+
+lib/rubytree.rb,0
+
+lib/tree/binarytree.rb,795
+module Tree::Tree
43,1906
+  class BinaryTreeNode::Tree::BinaryTreeNode
52,2215
+    def left_child::Tree::BinaryTreeNode#left_child
62,2498
+    def right_child::Tree::BinaryTreeNode#right_child
74,2889
+    def is_left_child?::Tree::BinaryTreeNode#is_left_child?
83,3165
+    def is_right_child?::Tree::BinaryTreeNode#is_right_child?
93,3496
+    def add::Tree::BinaryTreeNode#add
110,4153
+    def add_from_hash::Tree::BinaryTreeNode#add_from_hash
143,5539
+    def inordered_each::Tree::BinaryTreeNode#inordered_each
160,6096
+    def set_child_at::Tree::BinaryTreeNode#set_child_at
191,7032
+    def left_child=::Tree::BinaryTreeNode#left_child=
210,7700
+    def right_child=::Tree::BinaryTreeNode#right_child=
222,8069
+    def swap_children::Tree::BinaryTreeNode#swap_children
227,8215
+
+lib/tree/tree_deps.rb,0
+
+lib/tree/utils/camel_case_method_handler.rb,324
+module Tree::Tree
41,1848
+  module CamelCaseMethodHandler::Tree::CamelCaseMethodHandler
44,2004
+    def self.included::Tree::CamelCaseMethodHandler.included
45,2038
+      def method_missing::Tree::CamelCaseMethodHandler#method_missing
49,2186
+      def to_snake_case::Tree::CamelCaseMethodHandler#to_snake_case
66,2798
+
+lib/tree/utils/hash_converter.rb,265
+module Tree::Tree
40,1916
+  def self.included::Tree.included
42,1953
+  module ClassMethods::Tree::ClassMethods
49,2177
+    def from_hash::Tree::ClassMethods#from_hash
86,3823
+    def add_from_hash::Tree#add_from_hash
129,5519
+    def to_h::Tree#to_h
151,6367
+
+lib/tree/utils/json_converter.rb,258
+module Tree::Tree
42,1925
+  def self.included::Tree.included
44,1962
+  def as_json::Tree#as_json
61,2413
+  def to_json::Tree#to_json
89,3121
+  module ClassMethods::Tree::ClassMethods
94,3271
+    def json_create::Tree::ClassMethods#json_create
113,3986
+
+lib/tree/utils/metrics_methods.rb,718
+module Tree::Tree
41,1833
+  module TreeMetricsHandler::Tree::TreeMetricsHandler
43,1918
+    def self.included::Tree::TreeMetricsHandler.included
44,1948
+      def size::Tree::TreeMetricsHandler#size
56,2317
+      def length::Tree::TreeMetricsHandler#length
67,2661
+      def node_height::Tree::TreeMetricsHandler#node_height
80,3078
+      def node_depth::Tree::TreeMetricsHandler#node_depth
96,3689
+      def level::Tree::TreeMetricsHandler#level
105,3875
+      def depth::Tree::TreeMetricsHandler#depth
124,4560
+      def breadth::Tree::TreeMetricsHandler#breadth
140,5197
+      def in_degree::Tree::TreeMetricsHandler#in_degree
154,5660
+      def out_degree::Tree::TreeMetricsHandler#out_degree
165,5973
+
+lib/tree/utils/tree_merge_handler.rb,214
+module Tree::Tree
40,1769
+  def merge::Tree#merge
57,2500
+  def merge!::Tree#merge!
72,3134
+  def check_merge_prerequisites::Tree#check_merge_prerequisites
85,3441
+  def merge_trees::Tree#merge_trees
102,4086
+
+lib/tree/utils/utils.rb,27
+module Tree::Tree
39,1838
+
+lib/tree/version.rb,27
+module Tree::Tree
38,1723
+
+lib/tree.rb,2790
+module Tree::Tree
48,2158
+  class TreeNode::Tree::TreeNode
85,3731
+    attr_reader   :name::Tree::TreeNode#name
109,4522
+    attr_accessor :content::Tree::TreeNode#content
116,4721
+    attr_reader   :parent::Tree::TreeNode#parent
120,4837
+    def root::Tree::TreeNode#root
127,5049
+    def is_root?::Tree::TreeNode#is_root?
138,5355
+    def has_content?::Tree::TreeNode#has_content?
146,5538
+    def is_leaf?::Tree::TreeNode#is_leaf?
157,5792
+    def parentage::Tree::TreeNode#parentage
169,6167
+    def has_children?::Tree::TreeNode#has_children?
187,6593
+    def initialize::Tree::TreeNode#Tree::TreeNode.new
210,7419
+    def detached_copy::Tree::TreeNode#detached_copy
228,8036
+    def detached_subtree_copy::Tree::TreeNode#detached_subtree_copy
238,8322
+    alias :dup::Tree::TreeNode#dup
247,8583
+    def marshal_dump::Tree::TreeNode#marshal_dump
252,8761
+    def create_dump_rep::Tree::TreeNode#create_dump_rep
258,8929
+    def marshal_load::Tree::TreeNode#marshal_load
273,9467
+    def to_s::Tree::TreeNode#to_s
298,10251
+    def <<::Tree::TreeNode#<<
321,11022
+    def add::Tree::TreeNode#add
356,12550
+    def insertion_range::Tree::TreeNode#insertion_range
376,13512
+    def replace!::Tree::TreeNode#replace!
391,13930
+    def replace_with::Tree::TreeNode#replace_with
405,14303
+    def remove!::Tree::TreeNode#remove!
423,15035
+    def parent=::Tree::TreeNode#parent=
438,15438
+    def remove_from_parent!::Tree::TreeNode#remove_from_parent!
451,15823
+    def remove_all!::Tree::TreeNode#remove_all!
462,16195
+    def set_as_root!::Tree::TreeNode#set_as_root!
473,16424
+    def freeze_tree!::Tree::TreeNode#freeze_tree!
483,16750
+    def []::Tree::TreeNode#[]
523,18268
+    def each::Tree::TreeNode#each
548,19235
+    def preordered_each::Tree::TreeNode#preordered_each
576,20195
+    def postordered_each::Tree::TreeNode#postordered_each
588,20607
+    def breadth_each::Tree::TreeNode#breadth_each
624,22052
+    def children::Tree::TreeNode#children
650,23005
+    def each_leaf::Tree::TreeNode#each_leaf
671,23626
+    def first_child::Tree::TreeNode#first_child
688,24048
+    def last_child::Tree::TreeNode#last_child
696,24259
+    def first_sibling::Tree::TreeNode#first_sibling
712,24706
+    def is_first_sibling?::Tree::TreeNode#is_first_sibling?
722,24980
+    def last_sibling::Tree::TreeNode#last_sibling
736,25396
+    def is_last_sibling?::Tree::TreeNode#is_last_sibling?
746,25666
+    def siblings::Tree::TreeNode#siblings
762,26219
+    def is_only_child?::Tree::TreeNode#is_only_child?
781,26771
+    def next_sibling::Tree::TreeNode#next_sibling
794,27174
+    def previous_sibling::Tree::TreeNode#previous_sibling
810,27648
+    def <=>::Tree::TreeNode#<=>
826,28159
+    def print_tree::Tree::TreeNode#print_tree
836,28539
+
+test/run_test.rb,0
+
+test/test_binarytree.rb,1361
+module TestTree::TestTree
39,1717
+  class TestBinaryTreeNode::TestTree::TestBinaryTreeNode
41,1776
+    def setup::TestTree::TestBinaryTreeNode#setup
44,1868
+    def teardown::TestTree::TestBinaryTreeNode#teardown
52,2171
+    def test_initialize::TestTree::TestBinaryTreeNode#test_initialize
59,2330
+    def test_from_hash::TestTree::TestBinaryTreeNode#test_from_hash
66,2692
+    def test_add_from_hash::TestTree::TestBinaryTreeNode#test_add_from_hash
101,4024
+    def test_add::TestTree::TestBinaryTreeNode#test_add
134,5134
+    def test_inordered_each::TestTree::TestBinaryTreeNode#test_inordered_each
157,6048
+    def test_left_child::TestTree::TestBinaryTreeNode#test_left_child
201,7516
+    def test_right_child::TestTree::TestBinaryTreeNode#test_right_child
209,7829
+    def test_left_child_equals::TestTree::TestBinaryTreeNode#test_left_child_equals
217,8142
+    def test_right_child_equals::TestTree::TestBinaryTreeNode#test_right_child_equals
236,9132
+    def test_is_left_child_eh::TestTree::TestBinaryTreeNode#test_is_left_child_eh
256,10249
+    def test_is_right_child_eh::TestTree::TestBinaryTreeNode#test_is_right_child_eh
271,10788
+    def test_swap_children::TestTree::TestBinaryTreeNode#test_swap_children
285,11334
+    def test_old_camelCase_method_names::TestTree::TestBinaryTreeNode#test_old_camelCase_method_names
303,12217
+
+test/test_rubytree_require.rb,203
+module TestTree::TestTree
38,1678
+  class TestRequireRubytree::TestTree::TestRequireRubytree
41,1759
+    def test_create_a_simple_node::TestTree::TestRequireRubytree#test_create_a_simple_node
44,1884
+
+test/test_subclassed_node.rb,389
+module TestTree::TestTree
39,1688
+  class TestSubclassedTreeNode::TestTree::TestSubclassedTreeNode
42,1741
+    class MyNode::TestTree::TestSubclassedTreeNode::MyNode
45,1868
+      def my_dummy_method::TestTree::TestSubclassedTreeNode::MyNode#my_dummy_method
47,1967
+    def test_subclassed_camelcase_methods::TestTree::TestSubclassedTreeNode#test_subclassed_camelcase_methods
52,2026
+
+test/test_thread_and_fiber.rb,422
+module TestTree::TestTree
39,1695
+  class TestFiberAndThreadOnNode::TestTree::TestFiberAndThreadOnNode
41,1747
+    def create_long_depth_trees::TestTree::TestFiberAndThreadOnNode#create_long_depth_trees
44,1843
+    def test_fiber_for_recursion::TestTree::TestFiberAndThreadOnNode#test_fiber_for_recursion
59,2260
+    def test_thread_for_recursion::TestTree::TestFiberAndThreadOnNode#test_thread_for_recursion
73,2807
+
+test/test_tree.rb,6262
+module TestTree::TestTree
39,1725
+  class TestTreeNode::TestTree::TestTreeNode
41,1777
+    def setup::TestTree::TestTreeNode#setup
65,2610
+    def setup_test_tree::TestTree::TestTreeNode#setup_test_tree
77,3030
+    def teardown::TestTree::TestTreeNode#teardown
84,3180
+    def test_has_version_number::TestTree::TestTreeNode#test_has_version_number
89,3272
+    def test_root_setup::TestTree::TestTreeNode#test_root_setup
94,3423
+    def test_root::TestTree::TestTreeNode#test_root
111,4473
+    def test_from_hash::TestTree::TestTreeNode#test_from_hash
123,4974
+    def test_from_hash_with_nils::TestTree::TestTreeNode#test_from_hash_with_nils
175,6546
+    def test_add_from_hash::TestTree::TestTreeNode#test_add_from_hash
221,7902
+    def test_to_h::TestTree::TestTreeNode#test_to_h
253,8917
+    def test_to_h_from_hash_symmetry::TestTree::TestTreeNode#test_to_h_from_hash_symmetry
279,9496
+    def test_has_content_eh::TestTree::TestTreeNode#test_has_content_eh
295,9894
+    def test_length_is_size::TestTree::TestTreeNode#test_length_is_size
306,10352
+    def test_spaceship::TestTree::TestTreeNode#test_spaceship
312,10542
+    def test_is_comparable::TestTree::TestTreeNode#test_is_comparable
338,11325
+    def test_to_s::TestTree::TestTreeNode#test_to_s
356,12107
+    def test_first_sibling::TestTree::TestTreeNode#test_first_sibling
389,13825
+    def test_is_first_sibling_eh::TestTree::TestTreeNode#test_is_first_sibling_eh
402,14553
+    def test_is_last_sibling_eh::TestTree::TestTreeNode#test_is_last_sibling_eh
413,15036
+    def test_last_sibling::TestTree::TestTreeNode#test_last_sibling
424,15504
+    def test_siblings::TestTree::TestTreeNode#test_siblings
436,16158
+    def test_is_only_child_eh::TestTree::TestTreeNode#test_is_only_child_eh
464,17081
+    def test_next_sibling::TestTree::TestTreeNode#test_next_sibling
475,17517
+    def test_previous_sibling::TestTree::TestTreeNode#test_previous_sibling
486,18017
+    def test_add::TestTree::TestTreeNode#test_add
497,18546
+    def test_add_duplicate::TestTree::TestTreeNode#test_add_duplicate
518,19228
+    def test_add_at_specific_position::TestTree::TestTreeNode#test_add_at_specific_position
559,20656
+    def test_replace_bang::TestTree::TestTreeNode#test_replace_bang
623,23711
+    def test_replace_with::TestTree::TestTreeNode#test_replace_with
647,24756
+    def test_remove_bang::TestTree::TestTreeNode#test_remove_bang
665,25481
+    def test_remove_all_bang::TestTree::TestTreeNode#test_remove_all_bang
697,26444
+    def test_remove_from_parent_bang::TestTree::TestTreeNode#test_remove_from_parent_bang
707,26750
+    def test_children::TestTree::TestTreeNode#test_children
726,27465
+    def test_first_child::TestTree::TestTreeNode#test_first_child
762,29054
+    def test_last_child::TestTree::TestTreeNode#test_last_child
771,29382
+    def test_find::TestTree::TestTreeNode#test_find
780,29698
+    def test_parentage::TestTree::TestTreeNode#test_parentage
795,30293
+    def test_each::TestTree::TestTreeNode#test_each
804,30625
+    def test_each_leaf::TestTree::TestTreeNode#test_each_leaf
823,31309
+    def test_parent::TestTree::TestTreeNode#test_parent
850,32504
+    def test_indexed_access::TestTree::TestTreeNode#test_indexed_access
861,32923
+    def test_print_tree::TestTree::TestTreeNode#test_print_tree
872,33296
+    def test_marshal_dump::TestTree::TestTreeNode#test_marshal_dump
879,33456
+    alias test_marshal_load::TestTree::TestTreeNode#test_marshal_load
921,35578
+    def test_collect::TestTree::TestTreeNode#test_collect
924,35699
+    def test_freeze_tree_bang::TestTree::TestTreeNode#test_freeze_tree_bang
934,35965
+    def test_content::TestTree::TestTreeNode#test_content
948,36487
+    def test_depth::TestTree::TestTreeNode#test_depth
956,36878
+    def do_deprecated_depth::TestTree::TestTreeNode#do_deprecated_depth
967,37251
+    def test_node_height::TestTree::TestTreeNode#test_node_height
985,37819
+    def test_node_depth::TestTree::TestTreeNode#test_node_depth
1010,39028
+    def test_level::TestTree::TestTreeNode#test_level
1023,39465
+    def test_breadth::TestTree::TestTreeNode#test_breadth
1038,40008
+    def test_breadth_each::TestTree::TestTreeNode#test_breadth_each
1057,40655
+    def test_preordered_each::TestTree::TestTreeNode#test_preordered_each
1106,42240
+    def test_postordered_each::TestTree::TestTreeNode#test_postordered_each
1145,43494
+    def test_detached_copy::TestTree::TestTreeNode#test_detached_copy
1194,45031
+    def test_detached_subtree_copy::TestTree::TestTreeNode#test_detached_subtree_copy
1211,45759
+    def test_has_children_eh::TestTree::TestTreeNode#test_has_children_eh
1245,48011
+    def test_is_leaf_eh::TestTree::TestTreeNode#test_is_leaf_eh
1251,48173
+    def test_is_root_eh::TestTree::TestTreeNode#test_is_root_eh
1258,48379
+    def test_content_equals::TestTree::TestTreeNode#test_content_equals
1264,48542
+    def test_size::TestTree::TestTreeNode#test_size
1272,48807
+    def test_lt2::TestTree::TestTreeNode#test_lt2
1281,49071
+    def test_index::TestTree::TestTreeNode#test_index
1292,49563
+    def test_in_degree::TestTree::TestTreeNode#test_in_degree
1313,50659
+    def test_out_degree::TestTree::TestTreeNode#test_out_degree
1324,51126
+    def test_json_serialization::TestTree::TestTreeNode#test_json_serialization
1335,51613
+    def test_json_deserialization::TestTree::TestTreeNode#test_json_deserialization
1359,52413
+    def test_json_roundtrip::TestTree::TestTreeNode#test_json_roundtrip
1387,53599
+    def test_old_camelCase_method_names::TestTree::TestTreeNode#test_old_camelCase_method_names
1403,54340
+    def test_integer_node_names::TestTree::TestTreeNode#test_integer_node_names
1434,55408
+    def test_add_node_to_self_as_child::TestTree::TestTreeNode#test_add_node_to_self_as_child
1465,56638
+    def test_single_node_becomes_leaf::TestTree::TestTreeNode#test_single_node_becomes_leaf
1481,57151
+    def test_unique_node_names::TestTree::TestTreeNode#test_unique_node_names
1493,57572
+    def setup_other_test_tree::TestTree::TestTreeNode#setup_other_test_tree
1507,57927
+    def test_merge::TestTree::TestTreeNode#test_merge
1535,58916
+    def test_merge_bang::TestTree::TestTreeNode#test_merge_bang
1564,60354

data/TODO.org

@@ -186,8 +186,18 @@
 
 
 
+* R0.9.5
+** DONE Pull the =hash= converter code from [[https://github.com/markthomas/RubyTree/commits/master][Mark Thomas]] ([[Issue:13][Issue #13]]).                        :ARCHIVE:
+   CLOSED: [2014-11-01 Sat 20:10]
+   This was contributed by @jhamon.
+** DONE Misc. bug fixes                                                                   :ARCHIVE:
+   CLOSED: [2014-11-01 Sat 20:11]
+
+
+
+
 * Next Release
-  DEADLINE: <2014-03-02 Sun>
+  DEADLINE: <2014-12-01 Mon>
 ** STARTED [#A] Resolve the infinite loop bug if a node is added to itself as a child     :Partial:
    [[Issue:5][Issue #5.]]
 
@@ -219,19 +229,15 @@
       duplicates).  This needs to be a hash (to allow O(1) access),
       and will sacrifice memory.  There might be a need to
       restructure the internals to make better use of memory.
+** STARTED Convert all documentation to markdown mode.
 ** TODO Expand the examples section, and add supporting documentation
-** TODO Pull the =hash= converter code from [[https://github.com/markthomas/RubyTree/commits/master][Mark Thomas]] ([[Issue:13][Issue #13]]).
-** TODO Convert all documentation to markdown mode.
-
-
 * Unplanned / Not assigned to any release
-*** DONE [#A] Migrate the website and references from http://rubyforge.org/
+*** DONE [#A] Migrate the website and references from http://rubyforge.org/               :ARCHIVE:
     CLOSED: [2014-07-04 Fri 22:18]
-*** TODO Create a cycle-detection/validation mechanism to prevent cyclic graphs of nodes.
-*** DONE Revert the forced install of rubygem 2.1.11 from [[file:.travis.yml][.travis.yml]]
+*** DONE Revert the forced install of rubygem 2.1.11 from [[file:.travis.yml][.travis.yml]]                     :ARCHIVE:
     CLOSED: [2014-01-12 Sun 19:06]
     The issue seems to have been resolved with the 2.2.1 release of Rubygems.
-
+*** TODO Create a cycle-detection/validation mechanism to prevent cyclic graphs of nodes.
 *** TODO Create a generic validation method to check for various issues in the created tree.
 *** TODO Add a FAQ document to the project.
 *** TODO The semantic of length is probably unclear.  Should return the node_depth instead (or remove the method)

data/lib/tree.rb

@@ -89,6 +89,7 @@ module Tree
     include Tree::Utils::CamelCaseMethodHandler
     include Tree::Utils::JSONConverter
     include Tree::Utils::TreeMergeHandler
+    include Tree::Utils::HashConverter
 
     # @!group Core Attributes
 
@@ -380,6 +381,31 @@ module Tree
 
     private :insertion_range
 
+
+    # Replaces the specified child node with another child node on this node.
+    #
+    # @param [Tree::TreeNode] old_child The child node to be replaced.
+    # @param [Tree::TreeNode] new_child The child node to be replaced with.
+    #
+    # @return [Tree::TreeNode] The removed child node
+    def replace!(old_child, new_child)
+      child_index = @children.find_index(old_child)
+
+      old_child = remove! old_child
+      add new_child, child_index
+
+      return old_child
+    end
+
+    # Replaces the node with another node
+    #
+    # @param [Tree::TreeNode] node The node to replace this node with
+    #
+    # @return [Tree::TreeNode] The replaced child node
+    def replace_with(node)
+      @parent.replace!(self, node)
+    end
+
     # Removes the specified child node from this node.
     #
     # This method can also be used for *pruning* a sub-tree, in cases where the removed child node is
@@ -560,7 +586,7 @@ module Tree
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Enumerator] an enumerator on this tree, if a block is *not* given
     def postordered_each(&block)
-      return self.to_enum unless block_given?
+      return self.to_enum(:postordered_each) unless block_given?
 
       # Using a marked node in order to skip adding the children of nodes that
       # have already been visited. This allows the stack depth to be controlled,
@@ -596,7 +622,7 @@ module Tree
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Enumerator] an enumerator on this tree, if a block is *not* given
     def breadth_each(&block)
-      return self.to_enum unless block_given?
+      return self.to_enum(:breadth_each) unless block_given?
 
       node_queue = [self]       # Create a queue with self as the initial entry
 
@@ -805,20 +831,26 @@ module Tree
     # Pretty prints the (sub)tree rooted at this node.
     #
     # @param [Integer] level The indentation level (4 spaces) to start with.
-    def print_tree(level = 0)
+    # @param [Integer] max_depth optional maximum depth at which the printing with stop.
+    # @param [Proc] block optional block to use for rendering
+    def print_tree(level = 0, max_depth = nil, block = lambda { |node, prefix|  puts "#{prefix} #{node.name}" })
+      prefix = ''
+
       if is_root?
-        print "*"
+        prefix << '*'
       else
-        print "|" unless parent.is_last_sibling?
-        print(' ' * (level - 1) * 4)
-        print(is_last_sibling? ? "+" : "|")
-        print "---"
-        print(has_children? ? "+" : ">")
+        prefix << '|' unless parent.is_last_sibling?
+        prefix << (' ' * (level - 1) * 4)
+        prefix << (is_last_sibling? ? '+' : '|')
+        prefix << '---'
+        prefix << (has_children? ? '+' : '>')
       end
 
-      puts " #{name}"
+      block.call(self, prefix)
+
+      return unless max_depth.nil? || level < max_depth # Exit if the max level is defined, and reached.
 
-      children { |child| child.print_tree(level + 1) if child } # Child might be 'nil'
+      children { |child| child.print_tree(level + 1, max_depth, block) if child } # Child might be 'nil'
     end
 
   end

data/lib/tree/binarytree.rb

@@ -8,7 +8,7 @@
 # Author:: Anupam Sengupta (anupamsg@gmail.com)
 #
 
-# Copyright (c) 2007, 2008, 2009, 2010, 2012, 2013 Anupam Sengupta
+# Copyright (c) 2007, 2008, 2009, 2010, 2012, 2013, 2014 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -113,6 +113,38 @@ module Tree
       super(child)
     end
 
+
+    # Instantiate and insert child nodes from data in a Ruby +Hash+
+    #
+    # This method is used in conjunction with {Tree::TreeNode.from_hash} to
+    # provide a convenient way of building and inserting child nodes present
+    # in a Ruby hashes.
+    #
+    # This method will instantiate a {Tree::TreeNode} instance for each top-
+    # level key of the input hash, to be inserted as children of the receiver
+    # instance.
+    #
+    # Nested hashes are expected and further child nodes will be created and
+    # added accordingly. If a hash key is a single value that value will be
+    # used as the name for the node.  If a hash key is an Array, both node
+    # name and content will be populated.
+    #
+    # A leaf element of the tree should be represented as a hash key with
+    # corresponding value nil or {}.
+    #
+    # @example
+    #   root = Tree::TreeNode.new(:A, "Root content!")
+    #   root.add_from_hash({:B => {:D => {}}, [:C, "C content!"] => {}})
+    #
+    # @param [Hash] hashed_subtree The hash of child subtrees.
+    # @raise [ArgumentError] This exception is raised if hash contains too many children.
+    # @raise [ArgumentError] This exception is raised if a non-hash is passed.
+    # @return [Array] Array of child nodes added
+    def add_from_hash(hashed_subtree)
+      raise ArgumentError, "Too many children" if hashed_subtree.size + @children.size > 2
+      super(hashed_subtree)
+    end
+
     # Performs inorder traversal (including this node).
     #
     # @yieldparam node [Tree::BinaryTreeNode]  Each node (in-order).

data/lib/tree/tree_deps.rb

@@ -45,3 +45,4 @@ require 'tree/utils/metrics_methods'
 require 'tree/utils/camel_case_method_handler'
 require 'tree/utils/json_converter'
 require 'tree/utils/tree_merge_handler'
+require 'tree/utils/hash_converter'

data/lib/tree/utils/hash_converter.rb

@@ -0,0 +1,161 @@
+# hash_converter.rb - This file is part of the RubyTree package.
+#
+# = hash_converter.rb - Provides utility methods for converting between
+#   {Tree::TreeNode} and Ruby's native +Hash+.
+#
+# Author::  Jen Hamon (http://www.github.com/jhamon)
+#
+# Time-stamp: <2014-10-25 16:20:23 anupam>
+#
+# Copyright (C) 2014 Jen Hamon (http://www.github.com/jhamon) and
+#                    Anupam Sengupta <anupamsg@gmail.com>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# - Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# - Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# - Neither the name of the organization nor the names of its contributors may
+#   be used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module Tree::Utils::HashConverter
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Methods in {Tree::Utils::HashConverter::ClassMethods} will be added as
+  # class methods on any class mixing in the {Tree::Utils::HashConverter}
+  # module.
+  module ClassMethods
+
+    # Factory method builds a {Tree::TreeNode} from a +Hash+.
+    #
+    # This method will interpret each key of your +Hash+ as a {Tree::TreeNode}.
+    # Nested hashes are expected and child nodes will be added accordingly. If
+    # a hash key is a single value that value will be used as the name for the
+    # node.  If a hash key is an Array, both node name and content will be
+    # populated.
+    #
+    # A leaf element of the tree should be represented as a hash key with
+    # corresponding value +nil+ or +{}+.
+    #
+    # @example
+    #   TreeNode.from_hash({:A => {:B => {}, :C => {:D => {}, :E => {}}}})
+    #   # would be parsed into the following tree structure:
+    #   #    A
+    #   #   / \
+    #   #  B   C
+    #   #     / \
+    #   #    D   E
+    #
+    #   # The same tree would result from this nil-terminated Hash
+    #   {:A => {:B => nil, :C => {:D => nil, :E => nil}}}
+    #
+    #   # A tree with equivalent structure but with content present for
+    #   # nodes A and D could be built from a hash like this:
+    #   {[:A, "A content"] => {:B => {}, :C => {[:D, "D content"] => {}, :E => {}}}}
+    #
+    # @author Jen Hamon (http://www.github.com/jhamon)
+    # @param [Hash] hash Hash to build tree from.
+    # @return [Tree::TreeNode] The {Tree::TreeNode} instance representing the root of your tree.
+    #
+    # @raise [ArgumentError] This exception is raised if a non-Hash is passed.
+    # @raise [ArgumentError] This exception is raised if the hash has multiple top-level elements.
+    # @raise [ArgumentError] This exception is raised if the hash contains values that are not hashes or nils.
+
+    def from_hash(hash)
+      raise ArgumentError, "Argument must be a type of hash" unless hash.is_a?(Hash)
+      raise ArgumentError, "Hash must have one top-level element" if hash.size != 1
+
+      root, children = hash.first
+
+      unless [Hash, NilClass].include?(children.class)
+        raise ArgumentError, "Invalid child. Must be nil or hash."
+      end
+
+      node = self.new(*root)
+      node.add_from_hash(children) unless children.nil?
+      node
+    end
+  end
+
+    # Instantiate and insert child nodes from data in a Ruby +Hash+
+    #
+    # This method is used in conjunction with from_hash to provide a
+    # convenient way of building and inserting child nodes present in a Ruby
+    # hashes.
+    #
+    # This method will instantiate a node instance for each top-
+    # level key of the input hash, to be inserted as children of the receiver
+    # instance.
+    #
+    # Nested hashes are expected and further child nodes will be created and
+    # added accordingly. If a hash key is a single value that value will be
+    # used as the name for the node.  If a hash key is an Array, both node
+    # name and content will be populated.
+    #
+    # A leaf element of the tree should be represented as a hash key with
+    # corresponding value +nil+ or {}.
+    #
+    # @example
+    #   root = Tree::TreeNode.new(:A, "Root content!")
+    #   root.add_from_hash({:B => {:D => {}}, [:C, "C content!"] => {}})
+    #
+    # @author Jen Hamon (http://www.github.com/jhamon)
+    # @param [Hash] children The hash of child subtrees.
+    # @raise [ArgumentError] This exception is raised if a non-hash is passed.
+    # @return [Array] Array of child nodes added
+    # @see ClassMethods#from_hash
+    def add_from_hash(children)
+      raise ArgumentError, "Argument must be a type of hash" unless children.is_a?(Hash)
+
+      child_nodes = []
+      children.each do |child, grandchildren|
+        child_node = self.class.from_hash({child => grandchildren})
+        child_nodes << child_node
+        self << child_node
+      end
+
+      child_nodes
+    end
+
+    # Convert a node and its subtree into a Ruby hash.
+    #
+    # @example
+    #    root = Tree::TreeNode.new(:root, "root content")
+    #    root << Tree::TreeNode.new(:child1, "child1 content")
+    #    root << Tree::TreeNode.new(:child2, "child2 content")
+    #    root.to_h # => {[:root, "root content"] => { [:child1, "child1 content"] => {}, [:child2, "child2 content"] => {}}}
+    # @author Jen Hamon (http://www.github.com/jhamon)
+    # @return [Hash] Hash representation of tree.
+    def to_h
+      key = has_content? ? [name, content] : name
+
+      children_hash = {}
+      children do |child|
+        children_hash.merge! child.to_h
+      end
+
+      { key => children_hash }
+    end
+end

data/lib/tree/utils/json_converter.rb

@@ -1,12 +1,12 @@
-# json.rb - This file is part of the RubyTree package.
+# json_converter.rb - This file is part of the RubyTree package.
 #
-# = json.rb - Provides conversion to and from JSON.
+# = json_converter.rb - Provides conversion to and from JSON.
 #
 # Author::  Anupam Sengupta (anupamsg@gmail.com)
 #
-# Time-stamp: <2013-12-31 21:57:42 anupam>
+# Time-stamp: <2014-10-25 16:16:23 anupam>
 #
-# Copyright (C) 2012, 2013 Anupam Sengupta <anupamsg@gmail.com>
+# Copyright (C) 2012, 2013, 2014 Anupam Sengupta <anupamsg@gmail.com>
 #
 # All rights reserved.
 #

data/lib/tree/version.rb

@@ -37,5 +37,5 @@
 #
 module Tree
   # Rubytree Package Version
-  VERSION = '0.9.4'
+  VERSION = '0.9.5pre'
 end

data/test/test_binarytree.rb

@@ -63,6 +63,73 @@ module TestTree
       assert_equal(@root.children.size, 0, "Initially no children should be present")
     end
 
+    def test_from_hash
+      # Can make a root note without a name
+      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({})}
+      # Can't have multiple roots
+      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({:A => {}, :B => {}}) }
+
+      # Can't have more than 2 children
+      too_many_kids = {:A => {:B => {}, :C => {}, :D => {} } }
+      assert_raise(ArgumentError) { Tree::BinaryTreeNode.from_hash(too_many_kids) }
+
+      valid_hash = {:A => {:B => {}, :C => { :D => {} } } }
+      tree = Tree::BinaryTreeNode.from_hash(valid_hash)
+      #    A
+      #   / \
+      #  B   C
+      #      |
+      #      D
+
+      assert_same(tree.class, Tree::BinaryTreeNode)
+      assert_same(tree.name, :A)
+      assert_equal(tree.is_root?, true)
+      assert_equal(tree.is_leaf?, false)
+      assert_equal(tree.children.count, 2) # B, C, D
+      assert_equal(tree.size, 4)
+      assert_equal(tree.left_child.name, :B)
+      assert_equal(tree.right_child.name, :C)
+
+      valid_hash_with_content = {[:A, "Content!"] => {:B => {}, :C => { [:D, "More content"] => {} } } }
+      tree2 = Tree::BinaryTreeNode.from_hash(valid_hash_with_content)
+
+      assert_equal(tree2.class, Tree::BinaryTreeNode)
+      assert_equal(tree2.content, "Content!" )
+      assert_equal(tree2[:C][:D].content, "More content")
+    end
+
+    def test_add_from_hash
+      root = Tree::BinaryTreeNode.new("Root")
+
+      # Can't have too many children
+      too_many_kids = {:child1 => {}, :child2 => {}, :child3 => {}}
+      assert_raise(ArgumentError) { root.add_from_hash(too_many_kids) }
+      assert_equal(root.children.count, 0) # Nothing added
+
+      # Well behaved when adding nothing
+      assert_equal(root.add_from_hash({}), [])
+      assert_equal(root.size, 1)
+
+      valid_hash = {:A => {}, :B => { :C => {}, [:D, "leaf"] => {} } }
+      added = root.add_from_hash(valid_hash)
+      #   root
+      #   / \
+      #  A   B
+      #     / \
+      #    C   D
+
+      assert_equal(added.class, Array)
+      assert_equal(added.count, 2)
+      assert_equal(root.size, 5)
+      assert_equal(root.children.count, 2)
+      assert_equal(root[:B][:D].content, "leaf")
+
+      # Can't add more than two children
+      assert_raise(ArgumentError) { root.add_from_hash({:X => {}}) }
+      node = Tree::BinaryTreeNode.new("Root 2")
+      assert_raise(ArgumentError) { node.add_from_hash({:A => {}, :B => {}, :C => {}}) }
+    end
+
     # Test the add method.
     def test_add
       @root.add @left_child1

data/test/test_tree.rb

@@ -120,6 +120,177 @@ module TestTree
       assert_equal(2    , @root.node_height, "Root's height after adding the children should be 2")
     end
 
+    def test_from_hash
+      #      A
+      #    / | \
+      #   B  C  D
+      #  / \   /
+      # E   F G
+      #    / \
+      #   H   I
+
+      hash = {[:A, "Root content"] => {
+                    :B => {
+                          :E => {},
+                          :F => {
+                                :H => {},
+                                [:I, "Leaf content"] => {}
+                                }
+                           },
+                    :C => {},
+                    :D => {
+                          :G => {}
+                          }
+                    }
+             }
+
+      tree = Tree::TreeNode.from_hash(hash)
+
+      assert_same(tree.class, Tree::TreeNode)
+      assert_same(tree.name, :A)
+      assert_equal(tree.is_root?, true)
+      assert_equal(tree.is_leaf?, false)
+      assert_equal(tree.size, 9)
+      assert_equal(tree.content, "Root content")
+      assert_equal(tree.children.count, 3) # B, C, D
+
+      leaf_with_content = tree[:B][:F][:I]
+      assert_equal(leaf_with_content.content, "Leaf content")
+      assert_equal(leaf_with_content.is_leaf?, true)
+
+      leaf_without_content = tree[:C]
+      assert_equal(leaf_without_content.is_leaf?, true)
+
+      interior_node = tree[:B][:F]
+      assert_equal(interior_node.is_leaf?, false)
+      assert_equal(interior_node.children.count, 2)
+
+      # Can't make a node without a name
+      assert_raise (ArgumentError) { Tree::TreeNode.from_hash({}) }
+      # Can't have multiple roots
+      assert_raise (ArgumentError) { Tree::TreeNode.from_hash({:A => {}, :B => {}}) }
+
+    end
+
+    def test_from_hash_with_nils
+      #      A
+      #    / | \
+      #   B  C  D
+      #  / \   /
+      # E   F G
+      #    / \
+      #   H   I
+
+      hash = {[:A, "Root content"] => {
+                    :B => {
+                          :E => nil,
+                          :F => {
+                                :H => nil,
+                                [:I, "Leaf content"] => nil
+                                }
+                           },
+                    :C => nil,
+                    :D => {
+                          :G => nil
+                          }
+                    }
+             }
+
+      tree = Tree::TreeNode.from_hash(hash)
+
+      assert_same(tree.class, Tree::TreeNode)
+      assert_same(tree.name, :A)
+      assert_equal(tree.is_root?, true)
+      assert_equal(tree.is_leaf?, false)
+      assert_equal(tree.size, 9)
+      assert_equal(tree.content, "Root content")
+      assert_equal(tree.children.count, 3) # B, C, D
+
+      leaf_with_content = tree[:B][:F][:I]
+      assert_equal(leaf_with_content.content, "Leaf content")
+      assert_equal(leaf_with_content.is_leaf?, true)
+
+      leaf_without_content = tree[:C]
+      assert_equal(leaf_without_content.is_leaf?, true)
+
+      interior_node = tree[:B][:F]
+      assert_equal(interior_node.is_leaf?, false)
+      assert_equal(interior_node.children.count, 2)
+    end
+
+    def test_add_from_hash
+      tree = Tree::TreeNode.new(:A)
+
+      # Doesn't blow up when added an empty hash
+      hash = {}
+      assert_equal(tree.add_from_hash(hash), [])
+
+      # Okay, now try a real hash
+      hash = {:B => {:C => {:D => nil}, :E => {}, :F => {}}, [:G, "G content"] => {}}
+      #      A
+      #     / \
+      #    B   G
+      #   /|\
+      #  C E F
+      #  |
+      #  D
+
+      added_children = tree.add_from_hash(hash)
+      assert_equal(added_children.class, Array)
+      assert_equal(added_children.count, 2)
+      assert_equal(tree.size, 7)
+      assert_equal(tree[:G].content, "G content")
+      assert_equal(tree[:G].is_leaf?, true)
+      assert_equal(tree[:B].size, 5)
+      assert_equal(tree[:B].children.count, 3)
+
+      assert_raise (ArgumentError) { tree.add_from_hash([]) }
+      assert_raise (ArgumentError) { tree.add_from_hash("not a hash") }
+      assert_raise (ArgumentError) { tree.add_from_hash({:X => "Not a hash or nil"}) }
+    end
+
+    # Test exporting to ruby Hash
+    def test_to_h
+      a = Tree::TreeNode.new(:A)
+      b = Tree::TreeNode.new(:B)
+      c = Tree::TreeNode.new(:C)
+      d = Tree::TreeNode.new(:D)
+      e = Tree::TreeNode.new(:E)
+      f = Tree::TreeNode.new(:F)
+      g = Tree::TreeNode.new(:G)
+      #   A
+      #  / \
+      # B   C
+      # |  / \
+      # E F   G
+
+      a << b
+      a << c
+      c << f
+      c << g
+      b << e
+
+      exported = a.to_h
+      expected = {:A => {:B => {:E => {}}, :C => {:F => {}, :G => {}}}}
+      assert_equal(exported, expected)
+    end
+
+    # Test that from_hash and to_h are symmetric
+    def test_to_h_from_hash_symmetry
+      #     A
+      #    / \
+      #   B   C
+      #  /|\   \
+      # E F G   H
+      # |\      |
+      # I J     K
+
+      input = {:A => {:B => {:E => {:I => {}, :J =>{}}, :F => {}, :G => {}}, :C =>{:H => {:K => {}}}}}
+
+      node = Tree::TreeNode.from_hash(input)
+      assert_equal(node.to_h, input)
+    end
+
     # Test the presence of content in the nodes.
     def test_has_content_eh
       a_node = Tree::TreeNode.new("A Node")
@@ -448,6 +619,48 @@ module TestTree
       assert_equal(5, @root.children.size, "Should have five child nodes")
     end
 
+    # Test the replace! and replace_with! methods
+    def test_replace_bang
+      @root << @child1
+      @root << @child2
+      @root << @child3
+
+      assert_equal(4, @root.size, "Should have four nodes")
+      assert(@root.children.include?(@child1), "Should parent child1")
+      assert(@root.children.include?(@child2), "Should parent child2")
+      assert(@root.children.include?(@child3), "Should parent child3")
+      assert(!@root.children.include?(@child4), "Should not parent child4")
+
+      @root.replace!(@child2, @child4)
+
+      # Also test replacing with a node of the same name
+      @root.replace! @child4, @child4.detached_copy
+
+      assert_equal(4, @root.size, "Should have three nodes")
+      assert(@root.children.include?(@child1), "Should parent child1")
+      assert(!@root.children.include?(@child2), "Should not parent child2")
+      assert(@root.children.include?(@child3), "Should parent child3")
+      assert(@root.children.include?(@child4), "Should parent child4")
+      assert_equal(1, @root.children.find_index(@child4), "Should add child4 to index 1")
+    end
+
+    def test_replace_with
+      @root << @child1
+      @root << @child2
+
+      assert_equal(3, @root.size, "Should have three nodes")
+      assert(@root.children.include?(@child1), "Should parent child1")
+      assert(@root.children.include?(@child2), "Should parent child2")
+      assert(!@root.children.include?(@child3), "Should not parent child3")
+
+      @child2.replace_with @child3
+
+      assert_equal(3, @root.size, "Should have three nodes")
+      assert(@root.children.include?(@child1), "Should parent child1")
+      assert(!@root.children.include?(@child2), "Should not parent child2")
+      assert(@root.children.include?(@child3), "Should parent child3")
+    end
+
     # Test the remove! and remove_all! methods.
     def test_remove_bang
       @root << @child1
@@ -868,17 +1081,25 @@ module TestTree
       f << h
       j << k << z
 
-      # Create the response
-      result_array = Array.new
+      # Test when a block is given
+      result_array = []
       result = j.breadth_each { |node| result_array << node.detached_copy }
 
-      assert_equal(j, result)
+      assert_equal(j, result)   # The invocation target is returned
+
+      expected_array.each_index do |i|
+        assert_equal(expected_array[i].name, result_array[i].name)      # Match only the names.
+      end
+
+      assert_equal(Enumerator, j.breadth_each.class) if defined?(Enumerator.class ) # Without a block
+      assert_equal(Enumerable::Enumerator, j.breadth_each.class) if defined?(Enumerable::Enumerator.class) # Without a block
+
+      # Now test without a block
+      result_array = j.breadth_each.collect { |node| node}
       expected_array.each_index do |i|
         assert_equal(expected_array[i].name, result_array[i].name)      # Match only the names.
       end
 
-      assert_equal(Enumerator, j.breadth_each.class) if defined?(Enumerator.class )# Without a block
-      assert_equal(Enumerable::Enumerator, j.breadth_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
     end
 
     # Test the preordered_each method.
@@ -945,18 +1166,28 @@ module TestTree
       f << h
       j << k << z
 
+      # Test when a block is given
       result_array = []
       result = j.postordered_each { |node| result_array << node.detached_copy}
 
-      assert_equal(j, result)   # Each returns the invocation target
+      assert_equal(j, result)   # The invocation target is returned
+
+      expected_array.each_index do |i|
+        # Match only the names.
+        assert_equal(expected_array[i].name, result_array[i].name)
+      end
+
+      assert_equal(Enumerator, j.postordered_each.class) if defined?(Enumerator.class) # Without a block
+      assert_equal(Enumerable::Enumerator, j.postordered_each.class) if defined?(Enumerable::Enumerator.class) # Without a block
+
+      # Now test without a block
+      result_array = j.postordered_each.collect { |node| node }
 
       expected_array.each_index do |i|
         # Match only the names.
         assert_equal(expected_array[i].name, result_array[i].name)
       end
 
-      assert_equal(Enumerator, j.postordered_each.class) if defined?(Enumerator.class )# Without a block
-      assert_equal(Enumerable::Enumerator, j.postordered_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
     end
 
     # test the detached_copy method.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubytree
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5pre
 platform: ruby
 authors:
 - Anupam Sengupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: structured_warnings
@@ -136,6 +136,7 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- TAGS
 - TODO.org
 - examples/example_basic.rb
 - lib/rubytree.rb
@@ -143,6 +144,7 @@ files:
 - lib/tree/binarytree.rb
 - lib/tree/tree_deps.rb
 - lib/tree/utils/camel_case_method_handler.rb
+- lib/tree/utils/hash_converter.rb
 - lib/tree/utils/json_converter.rb
 - lib/tree/utils/metrics_methods.rb
 - lib/tree/utils/tree_merge_handler.rb
@@ -179,12 +181,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A generic tree data structure.