RubyGems - rubytree - Versions diffs - 0.9.4 → 0.9.5pre - Mend

rubytree 0.9.4 → 0.9.5pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

checksums.yaml +4 -4
data/Gemfile.lock +12 -10
data/History.rdoc +12 -0
data/README.md +1 -0
data/TAGS +242 -0
data/TODO.org +15 -9
data/lib/tree.rb +43 -11
data/lib/tree/binarytree.rb +33 -1
data/lib/tree/tree_deps.rb +1 -0
data/lib/tree/utils/hash_converter.rb +161 -0
data/lib/tree/utils/json_converter.rb +4 -4
data/lib/tree/version.rb +1 -1
data/test/test_binarytree.rb +67 -0
data/test/test_tree.rb +239 -8
metadata +7 -5

checksums.yaml CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,242 @@
+lib/rubytree.rb,0
+lib/tree/binarytree.rb,795
+module Tree::Tree43,1906
+  class BinaryTreeNode::Tree::BinaryTreeNode52,2215
+    def left_child::Tree::BinaryTreeNode#left_child62,2498
+    def right_child::Tree::BinaryTreeNode#right_child74,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#add110,4153
+    def add_from_hash::Tree::BinaryTreeNode#add_from_hash143,5539
+    def inordered_each::Tree::BinaryTreeNode#inordered_each160,6096
+    def set_child_at::Tree::BinaryTreeNode#set_child_at191,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_children227,8215
+lib/tree/tree_deps.rb,0
+lib/tree/utils/camel_case_method_handler.rb,324
+module Tree::Tree41,1848
+  module CamelCaseMethodHandler::Tree::CamelCaseMethodHandler44,2004
+    def self.included::Tree::CamelCaseMethodHandler.included45,2038
+      def method_missing::Tree::CamelCaseMethodHandler#method_missing49,2186
+      def to_snake_case::Tree::CamelCaseMethodHandler#to_snake_case66,2798
+lib/tree/utils/hash_converter.rb,265
+module Tree::Tree40,1916
+  def self.included::Tree.included42,1953
+  module ClassMethods::Tree::ClassMethods49,2177
+    def from_hash::Tree::ClassMethods#from_hash86,3823
+    def add_from_hash::Tree#add_from_hash129,5519
+    def to_h::Tree#to_h151,6367
+lib/tree/utils/json_converter.rb,258
+module Tree::Tree42,1925
+  def self.included::Tree.included44,1962
+  def as_json::Tree#as_json61,2413
+  def to_json::Tree#to_json89,3121
+  module ClassMethods::Tree::ClassMethods94,3271
+    def json_create::Tree::ClassMethods#json_create113,3986
+lib/tree/utils/metrics_methods.rb,718
+module Tree::Tree41,1833
+  module TreeMetricsHandler::Tree::TreeMetricsHandler43,1918
+    def self.included::Tree::TreeMetricsHandler.included44,1948
+      def size::Tree::TreeMetricsHandler#size56,2317
+      def length::Tree::TreeMetricsHandler#length67,2661
+      def node_height::Tree::TreeMetricsHandler#node_height80,3078
+      def node_depth::Tree::TreeMetricsHandler#node_depth96,3689
+      def level::Tree::TreeMetricsHandler#level105,3875
+      def depth::Tree::TreeMetricsHandler#depth124,4560
+      def breadth::Tree::TreeMetricsHandler#breadth140,5197
+      def in_degree::Tree::TreeMetricsHandler#in_degree154,5660
+      def out_degree::Tree::TreeMetricsHandler#out_degree165,5973
+lib/tree/utils/tree_merge_handler.rb,214
+module Tree::Tree40,1769
+  def merge::Tree#merge57,2500
+  def merge!::Tree#merge!72,3134
+  def check_merge_prerequisites::Tree#check_merge_prerequisites85,3441
+  def merge_trees::Tree#merge_trees102,4086
+lib/tree/utils/utils.rb,27
+module Tree::Tree39,1838
+lib/tree/version.rb,27
+module Tree::Tree38,1723
+lib/tree.rb,2790
+module Tree::Tree48,2158
+  class TreeNode::Tree::TreeNode85,3731
+    attr_reader   :name::Tree::TreeNode#name109,4522
+    attr_accessor :content::Tree::TreeNode#content116,4721
+    attr_reader   :parent::Tree::TreeNode#parent120,4837
+    def root::Tree::TreeNode#root127,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#parentage169,6167
+    def has_children?::Tree::TreeNode#has_children?187,6593
+    def initialize::Tree::TreeNode#Tree::TreeNode.new210,7419
+    def detached_copy::Tree::TreeNode#detached_copy228,8036
+    def detached_subtree_copy::Tree::TreeNode#detached_subtree_copy238,8322
+    alias :dup::Tree::TreeNode#dup247,8583
+    def marshal_dump::Tree::TreeNode#marshal_dump252,8761
+    def create_dump_rep::Tree::TreeNode#create_dump_rep258,8929
+    def marshal_load::Tree::TreeNode#marshal_load273,9467
+    def to_s::Tree::TreeNode#to_s298,10251
+    def <<::Tree::TreeNode#<<321,11022
+    def add::Tree::TreeNode#add356,12550
+    def insertion_range::Tree::TreeNode#insertion_range376,13512
+    def replace!::Tree::TreeNode#replace!391,13930
+    def replace_with::Tree::TreeNode#replace_with405,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#each548,19235
+    def preordered_each::Tree::TreeNode#preordered_each576,20195
+    def postordered_each::Tree::TreeNode#postordered_each588,20607
+    def breadth_each::Tree::TreeNode#breadth_each624,22052
+    def children::Tree::TreeNode#children650,23005
+    def each_leaf::Tree::TreeNode#each_leaf671,23626
+    def first_child::Tree::TreeNode#first_child688,24048
+    def last_child::Tree::TreeNode#last_child696,24259
+    def first_sibling::Tree::TreeNode#first_sibling712,24706
+    def is_first_sibling?::Tree::TreeNode#is_first_sibling?722,24980
+    def last_sibling::Tree::TreeNode#last_sibling736,25396
+    def is_last_sibling?::Tree::TreeNode#is_last_sibling?746,25666
+    def siblings::Tree::TreeNode#siblings762,26219
+    def is_only_child?::Tree::TreeNode#is_only_child?781,26771
+    def next_sibling::Tree::TreeNode#next_sibling794,27174
+    def previous_sibling::Tree::TreeNode#previous_sibling810,27648
+    def <=>::Tree::TreeNode#<=>826,28159
+    def print_tree::Tree::TreeNode#print_tree836,28539
+test/run_test.rb,0
+test/test_binarytree.rb,1361
+module TestTree::TestTree39,1717
+  class TestBinaryTreeNode::TestTree::TestBinaryTreeNode41,1776
+    def setup::TestTree::TestBinaryTreeNode#setup44,1868
+    def teardown::TestTree::TestBinaryTreeNode#teardown52,2171
+    def test_initialize::TestTree::TestBinaryTreeNode#test_initialize59,2330
+    def test_from_hash::TestTree::TestBinaryTreeNode#test_from_hash66,2692
+    def test_add_from_hash::TestTree::TestBinaryTreeNode#test_add_from_hash101,4024
+    def test_add::TestTree::TestBinaryTreeNode#test_add134,5134
+    def test_inordered_each::TestTree::TestBinaryTreeNode#test_inordered_each157,6048
+    def test_left_child::TestTree::TestBinaryTreeNode#test_left_child201,7516
+    def test_right_child::TestTree::TestBinaryTreeNode#test_right_child209,7829
+    def test_left_child_equals::TestTree::TestBinaryTreeNode#test_left_child_equals217,8142
+    def test_right_child_equals::TestTree::TestBinaryTreeNode#test_right_child_equals236,9132
+    def test_is_left_child_eh::TestTree::TestBinaryTreeNode#test_is_left_child_eh256,10249
+    def test_is_right_child_eh::TestTree::TestBinaryTreeNode#test_is_right_child_eh271,10788
+    def test_swap_children::TestTree::TestBinaryTreeNode#test_swap_children285,11334
+    def test_old_camelCase_method_names::TestTree::TestBinaryTreeNode#test_old_camelCase_method_names303,12217
+test/test_rubytree_require.rb,203
+module TestTree::TestTree38,1678
+  class TestRequireRubytree::TestTree::TestRequireRubytree41,1759
+    def test_create_a_simple_node::TestTree::TestRequireRubytree#test_create_a_simple_node44,1884
+test/test_subclassed_node.rb,389
+module TestTree::TestTree39,1688
+  class TestSubclassedTreeNode::TestTree::TestSubclassedTreeNode42,1741
+    class MyNode::TestTree::TestSubclassedTreeNode::MyNode45,1868
+      def my_dummy_method::TestTree::TestSubclassedTreeNode::MyNode#my_dummy_method47,1967
+    def test_subclassed_camelcase_methods::TestTree::TestSubclassedTreeNode#test_subclassed_camelcase_methods52,2026
+test/test_thread_and_fiber.rb,422
+module TestTree::TestTree39,1695
+  class TestFiberAndThreadOnNode::TestTree::TestFiberAndThreadOnNode41,1747
+    def create_long_depth_trees::TestTree::TestFiberAndThreadOnNode#create_long_depth_trees44,1843
+    def test_fiber_for_recursion::TestTree::TestFiberAndThreadOnNode#test_fiber_for_recursion59,2260
+    def test_thread_for_recursion::TestTree::TestFiberAndThreadOnNode#test_thread_for_recursion73,2807
+test/test_tree.rb,6262
+module TestTree::TestTree39,1725
+  class TestTreeNode::TestTree::TestTreeNode41,1777
+    def setup::TestTree::TestTreeNode#setup65,2610
+    def setup_test_tree::TestTree::TestTreeNode#setup_test_tree77,3030
+    def teardown::TestTree::TestTreeNode#teardown84,3180
+    def test_has_version_number::TestTree::TestTreeNode#test_has_version_number89,3272
+    def test_root_setup::TestTree::TestTreeNode#test_root_setup94,3423
+    def test_root::TestTree::TestTreeNode#test_root111,4473
+    def test_from_hash::TestTree::TestTreeNode#test_from_hash123,4974
+    def test_from_hash_with_nils::TestTree::TestTreeNode#test_from_hash_with_nils175,6546
+    def test_add_from_hash::TestTree::TestTreeNode#test_add_from_hash221,7902
+    def test_to_h::TestTree::TestTreeNode#test_to_h253,8917
+    def test_to_h_from_hash_symmetry::TestTree::TestTreeNode#test_to_h_from_hash_symmetry279,9496
+    def test_has_content_eh::TestTree::TestTreeNode#test_has_content_eh295,9894
+    def test_length_is_size::TestTree::TestTreeNode#test_length_is_size306,10352
+    def test_spaceship::TestTree::TestTreeNode#test_spaceship312,10542
+    def test_is_comparable::TestTree::TestTreeNode#test_is_comparable338,11325
+    def test_to_s::TestTree::TestTreeNode#test_to_s356,12107
+    def test_first_sibling::TestTree::TestTreeNode#test_first_sibling389,13825
+    def test_is_first_sibling_eh::TestTree::TestTreeNode#test_is_first_sibling_eh402,14553
+    def test_is_last_sibling_eh::TestTree::TestTreeNode#test_is_last_sibling_eh413,15036
+    def test_last_sibling::TestTree::TestTreeNode#test_last_sibling424,15504
+    def test_siblings::TestTree::TestTreeNode#test_siblings436,16158
+    def test_is_only_child_eh::TestTree::TestTreeNode#test_is_only_child_eh464,17081
+    def test_next_sibling::TestTree::TestTreeNode#test_next_sibling475,17517
+    def test_previous_sibling::TestTree::TestTreeNode#test_previous_sibling486,18017
+    def test_add::TestTree::TestTreeNode#test_add497,18546
+    def test_add_duplicate::TestTree::TestTreeNode#test_add_duplicate518,19228
+    def test_add_at_specific_position::TestTree::TestTreeNode#test_add_at_specific_position559,20656
+    def test_replace_bang::TestTree::TestTreeNode#test_replace_bang623,23711
+    def test_replace_with::TestTree::TestTreeNode#test_replace_with647,24756
+    def test_remove_bang::TestTree::TestTreeNode#test_remove_bang665,25481
+    def test_remove_all_bang::TestTree::TestTreeNode#test_remove_all_bang697,26444
+    def test_remove_from_parent_bang::TestTree::TestTreeNode#test_remove_from_parent_bang707,26750
+    def test_children::TestTree::TestTreeNode#test_children726,27465
+    def test_first_child::TestTree::TestTreeNode#test_first_child762,29054
+    def test_last_child::TestTree::TestTreeNode#test_last_child771,29382
+    def test_find::TestTree::TestTreeNode#test_find780,29698
+    def test_parentage::TestTree::TestTreeNode#test_parentage795,30293
+    def test_each::TestTree::TestTreeNode#test_each804,30625
+    def test_each_leaf::TestTree::TestTreeNode#test_each_leaf823,31309
+    def test_parent::TestTree::TestTreeNode#test_parent850,32504
+    def test_indexed_access::TestTree::TestTreeNode#test_indexed_access861,32923
+    def test_print_tree::TestTree::TestTreeNode#test_print_tree872,33296
+    def test_marshal_dump::TestTree::TestTreeNode#test_marshal_dump879,33456
+    alias test_marshal_load::TestTree::TestTreeNode#test_marshal_load921,35578
+    def test_collect::TestTree::TestTreeNode#test_collect924,35699
+    def test_freeze_tree_bang::TestTree::TestTreeNode#test_freeze_tree_bang934,35965
+    def test_content::TestTree::TestTreeNode#test_content948,36487
+    def test_depth::TestTree::TestTreeNode#test_depth956,36878
+    def do_deprecated_depth::TestTree::TestTreeNode#do_deprecated_depth967,37251
+    def test_node_height::TestTree::TestTreeNode#test_node_height985,37819
+    def test_node_depth::TestTree::TestTreeNode#test_node_depth1010,39028
+    def test_level::TestTree::TestTreeNode#test_level1023,39465
+    def test_breadth::TestTree::TestTreeNode#test_breadth1038,40008
+    def test_breadth_each::TestTree::TestTreeNode#test_breadth_each1057,40655
+    def test_preordered_each::TestTree::TestTreeNode#test_preordered_each1106,42240
+    def test_postordered_each::TestTree::TestTreeNode#test_postordered_each1145,43494
+    def test_detached_copy::TestTree::TestTreeNode#test_detached_copy1194,45031
+    def test_detached_subtree_copy::TestTree::TestTreeNode#test_detached_subtree_copy1211,45759
+    def test_has_children_eh::TestTree::TestTreeNode#test_has_children_eh1245,48011
+    def test_is_leaf_eh::TestTree::TestTreeNode#test_is_leaf_eh1251,48173
+    def test_is_root_eh::TestTree::TestTreeNode#test_is_root_eh1258,48379
+    def test_content_equals::TestTree::TestTreeNode#test_content_equals1264,48542
+    def test_size::TestTree::TestTreeNode#test_size1272,48807
+    def test_lt2::TestTree::TestTreeNode#test_lt21281,49071
+    def test_index::TestTree::TestTreeNode#test_index1292,49563
+    def test_in_degree::TestTree::TestTreeNode#test_in_degree1313,50659
+    def test_out_degree::TestTree::TestTreeNode#test_out_degree1324,51126
+    def test_json_serialization::TestTree::TestTreeNode#test_json_serialization1335,51613
+    def test_json_deserialization::TestTree::TestTreeNode#test_json_deserialization1359,52413
+    def test_json_roundtrip::TestTree::TestTreeNode#test_json_roundtrip1387,53599
+    def test_old_camelCase_method_names::TestTree::TestTreeNode#test_old_camelCase_method_names1403,54340
+    def test_integer_node_names::TestTree::TestTreeNode#test_integer_node_names1434,55408
+    def test_add_node_to_self_as_child::TestTree::TestTreeNode#test_add_node_to_self_as_child1465,56638
+    def test_single_node_becomes_leaf::TestTree::TestTreeNode#test_single_node_becomes_leaf1481,57151
+    def test_unique_node_names::TestTree::TestTreeNode#test_unique_node_names1493,57572
+    def setup_other_test_tree::TestTree::TestTreeNode#setup_other_test_tree1507,57927
+    def test_merge::TestTree::TestTreeNode#test_merge1535,58916
+    def test_merge_bang::TestTree::TestTreeNode#test_merge_bang1564,60354

data/TODO.org CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

data/test/test_binarytree.rb CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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.