rubytree 0.9.7 → 1.0.0

data/test/run_test.rb

@@ -32,13 +32,13 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-lib_dir  = File.join(base_dir, "lib")
-test_dir = File.join(base_dir, "test")
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+lib_dir  = File.join(base_dir, 'lib')
+test_dir = File.join(base_dir, 'test')
 
 $LOAD_PATH.unshift(lib_dir)
 
-if ENV["COVERAGE"]
+if ENV['COVERAGE']
   begin
     require 'simplecov'
     require 'coveralls'
@@ -51,10 +51,10 @@ if ENV["COVERAGE"]
       add_group 'Internal Utilities', '/lib/tree/utils/.*.rb'
     end
   rescue LoadError => e
-    puts "Could not load simplecov; continuing without code coverage"
+    puts 'Could not load simplecov; continuing without code coverage' + e.cause
   end
 end
 
 require 'test/unit'
 
-exit Test::Unit::AutoRunner.run(true, test_dir)
+Test::Unit::AutoRunner.run(true, test_dir)

data/test/test_binarytree.rb

@@ -3,7 +3,7 @@
 # test_binarytree.rb - This file is part of the RubyTree package.
 #
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012, 2013, 2015 Anupam Sengupta
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012, 2013, 2015, 2017 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -34,7 +34,7 @@
 #
 
 require 'test/unit'
-require 'tree/binarytree'
+require_relative '../lib/tree/binarytree'
 
 module TestTree
   # Test class for the binary tree node.
@@ -42,10 +42,10 @@ module TestTree
 
     # Setup the test data scaffolding.
     def setup
-      @root = Tree::BinaryTreeNode.new("ROOT", "Root Node")
+      @root = Tree::BinaryTreeNode.new('ROOT', 'Root Node')
 
-      @left_child1  = Tree::BinaryTreeNode.new("A Child at Left", "Child Node @ left")
-      @right_child1 = Tree::BinaryTreeNode.new("B Child at Right", "Child Node @ right")
+      @left_child1  = Tree::BinaryTreeNode.new('A Child at Left', 'Child Node @ left')
+      @right_child1 = Tree::BinaryTreeNode.new('B Child at Right', 'Child Node @ right')
     end
 
     # Tear down the test data scaffolding.
@@ -58,22 +58,22 @@ module TestTree
     # Test initialization of the binary tree.
     def test_initialize
       assert_not_nil(@root, "Binary tree's Root should have been created")
-      assert_nil(@root.left_child, "The initial left child of root should be nil")
-      assert_nil(@root.right_child, "The initial right child of root should be nil")
-      assert_equal(@root.children.size, 0, "Initially no children should be present")
+      assert_nil(@root.left_child, 'The initial left child of root should be nil')
+      assert_nil(@root.right_child, 'The initial right child of root should be nil')
+      assert_equal(@root.children.size, 0, 'Initially no children should be present')
     end
 
     def test_from_hash
       # Can't make a root node without a name
       assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({})}
       # Can't have multiple roots
-      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({:A => {}, :B => {}}) }
+      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({A: {}, B: {}}) }
 
       # Can't have more than 2 children
-      too_many_kids = {:A => {:B => {}, :C => {}, :D => {} } }
+      too_many_kids = {A: {B: {}, C: {}, D: {}}}
       assert_raise(ArgumentError) { Tree::BinaryTreeNode.from_hash(too_many_kids) }
 
-      valid_hash = {:A => {:B => {}, :C => { :D => {} } } }
+      valid_hash = {A: {B: {}, C: {D: {}}}}
       tree = Tree::BinaryTreeNode.from_hash(valid_hash)
       #    A
       #   / \
@@ -88,19 +88,19 @@ module TestTree
       assert_equal(2, tree.children.count) # B, C, D
       assert_equal(4, tree.size)
 
-      valid_hash_with_content = {[:A, "Content!"] => {:B => {}, :C => { [:D, "More content"] => {} } } }
+      valid_hash_with_content = {[:A, 'Content!'] => {B: {}, C: {[:D, 'More content'] => {}}} }
       tree2 = Tree::BinaryTreeNode.from_hash(valid_hash_with_content)
 
       assert_equal(Tree::BinaryTreeNode, tree2.class)
-      assert_equal("Content!" , tree2.content)
-      assert_equal("More content", tree2[:C][:D].content)
+      assert_equal('Content!', tree2.content)
+      assert_equal('More content', tree2[:C][:D].content)
     end
 
     def test_add_from_hash
-      root = Tree::BinaryTreeNode.new("Root")
+      root = Tree::BinaryTreeNode.new('Root')
 
       # Can't have too many children
-      too_many_kids = {:child1 => {}, :child2 => {}, :child3 => {}}
+      too_many_kids = {child1: {}, child2: {}, child3: {}}
       assert_raise(ArgumentError) { root.add_from_hash(too_many_kids) }
       assert_equal(0, root.children.count) # Nothing added
 
@@ -108,7 +108,7 @@ module TestTree
       assert_equal([], root.add_from_hash({}))
       assert_equal(1, root.size)
 
-      valid_hash = {:A => {}, :B => { :C => {}, [:D, "leaf"] => {} } }
+      valid_hash = {A: {}, B: {C: {}, [:D, 'leaf'] => {}}}
       added = root.add_from_hash(valid_hash)
       #   root
       #   / \
@@ -120,48 +120,48 @@ module TestTree
       assert_equal(2, added.count)
       assert_equal(5, root.size)
       assert_equal(root.children.count, 2)
-      assert_equal("leaf", root[:B][:D].content)
+      assert_equal('leaf', root[:B][:D].content)
 
       # 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 => {}}) }
+      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
-      assert(!@left_child1.is_root?, "Left child1 cannot be a root after addition to the ROOT node")
+      assert(!@left_child1.is_root?, 'Left child1 cannot be a root after addition to the ROOT node')
 
-      assert_same(@left_child1, @root.left_child, "The left node should be left_child1")
-      assert_same(@left_child1, @root.first_child, "The first node should be left_child1")
+      assert_same(@left_child1, @root.left_child, 'The left node should be left_child1')
+      assert_same(@left_child1, @root.first_child, 'The first node should be left_child1')
 
       @root.add @right_child1
-      assert(!@right_child1.is_root?, "Right child1 cannot be a root after addition to the ROOT node")
+      assert(!@right_child1.is_root?, 'Right child1 cannot be a root after addition to the ROOT node')
 
-      assert_same(@right_child1, @root.right_child, "The right node should be right_child1")
-      assert_same(@right_child1, @root.last_child, "The first node should be right_child1")
+      assert_same(@right_child1, @root.right_child, 'The right node should be right_child1')
+      assert_same(@right_child1, @root.last_child, 'The first node should be right_child1')
 
       assert_raise ArgumentError do
-        @root.add Tree::BinaryTreeNode.new("The third child!")
+        @root.add Tree::BinaryTreeNode.new('The third child!')
       end
 
       assert_raise ArgumentError do
-        @root << Tree::BinaryTreeNode.new("The third child!")
+        @root << Tree::BinaryTreeNode.new('The third child!')
       end
     end
 
     # Test the inordered_each method.
     def test_inordered_each
-      a = Tree::BinaryTreeNode.new("a")
-      b = Tree::BinaryTreeNode.new("b")
-      c = Tree::BinaryTreeNode.new("c")
-      d = Tree::BinaryTreeNode.new("d")
-      e = Tree::BinaryTreeNode.new("e")
-      f = Tree::BinaryTreeNode.new("f")
-      g = Tree::BinaryTreeNode.new("g")
-      h = Tree::BinaryTreeNode.new("h")
-      i = Tree::BinaryTreeNode.new("i")
+      a = Tree::BinaryTreeNode.new('a')
+      b = Tree::BinaryTreeNode.new('b')
+      c = Tree::BinaryTreeNode.new('c')
+      d = Tree::BinaryTreeNode.new('d')
+      e = Tree::BinaryTreeNode.new('e')
+      f = Tree::BinaryTreeNode.new('f')
+      g = Tree::BinaryTreeNode.new('g')
+      h = Tree::BinaryTreeNode.new('h')
+      i = Tree::BinaryTreeNode.new('i')
 
       # Create the following Tree
       #        f         <-- level 0 (Root)
@@ -186,9 +186,9 @@ module TestTree
 
       assert_equal(f, result)   # each should return the original object
 
-      expected_array.each_index do |i|
+      expected_array.each_index do |idx|
         # Match only the names.
-        assert_equal(expected_array[i].name, result_array[i].name)
+        assert_equal(expected_array[idx].name, result_array[idx].name)
       end
 
       assert_equal(Enumerator, f.inordered_each.class) if defined?(Enumerator.class )# Without a block
@@ -200,7 +200,7 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@left_child1, @root.left_child, "The left child should be 'left_child1")
-      assert_not_same(@right_child1, @root.left_child, "The right_child1 is not the left child")
+      assert_not_same(@right_child1, @root.left_child, 'The right_child1 is not the left child')
     end
 
     # Test the right_child method.
@@ -208,7 +208,7 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@right_child1, @root.right_child, "The right child should be 'right_child1")
-      assert_not_same(@left_child1, @root.right_child, "The left_child1 is not the left child")
+      assert_not_same(@left_child1, @root.right_child, 'The left_child1 is not the left child')
     end
 
     # Test left_child= method.
@@ -216,18 +216,18 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@left_child1, @root.left_child, "The left child should be 'left_child1")
-      assert(!@left_child1.is_root?, "The left child now cannot be a root.")
+      assert(!@left_child1.is_root?, 'The left child now cannot be a root.')
 
-      @root.left_child = Tree::BinaryTreeNode.new("New Left Child")
-      assert(!@root.left_child.is_root?, "The left child now cannot be a root.")
-      assert_equal("New Left Child", @root.left_child.name, "The left child should now be the new child")
-      assert_equal("B Child at Right", @root.last_child.name, "The last child should now be the right child")
+      @root.left_child = Tree::BinaryTreeNode.new('New Left Child')
+      assert(!@root.left_child.is_root?, 'The left child now cannot be a root.')
+      assert_equal('New Left Child', @root.left_child.name, 'The left child should now be the new child')
+      assert_equal('B Child at Right', @root.last_child.name, 'The last child should now be the right child')
 
       # Now set the left child as nil, and retest
       @root.left_child = nil
-      assert_nil(@root.left_child, "The left child should now be nil")
-      assert_nil(@root.first_child, "The first child is now nil")
-      assert_equal("B Child at Right", @root.last_child.name, "The last child should now be the right child")
+      assert_nil(@root.left_child, 'The left child should now be nil')
+      assert_nil(@root.first_child, 'The first child is now nil')
+      assert_equal('B Child at Right', @root.last_child.name, 'The last child should now be the right child')
     end
 
     # Test right_child= method.
@@ -235,19 +235,19 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@right_child1, @root.right_child, "The right child should be 'right_child1")
-      assert(!@right_child1.is_root?, "The right child now cannot be a root.")
+      assert(!@right_child1.is_root?, 'The right child now cannot be a root.')
 
-      @root.right_child = Tree::BinaryTreeNode.new("New Right Child")
-      assert(!@root.right_child.is_root?, "The right child now cannot be a root.")
-      assert_equal("New Right Child", @root.right_child.name, "The right child should now be the new child")
-      assert_equal("A Child at Left", @root.first_child.name, "The first child should now be the left child")
-      assert_equal("New Right Child", @root.last_child.name, "The last child should now be the right child")
+      @root.right_child = Tree::BinaryTreeNode.new('New Right Child')
+      assert(!@root.right_child.is_root?, 'The right child now cannot be a root.')
+      assert_equal('New Right Child', @root.right_child.name, 'The right child should now be the new child')
+      assert_equal('A Child at Left', @root.first_child.name, 'The first child should now be the left child')
+      assert_equal('New Right Child', @root.last_child.name, 'The last child should now be the right child')
 
       # Now set the right child as nil, and retest
       @root.right_child = nil
-      assert_nil(@root.right_child, "The right child should now be nil")
-      assert_equal("A Child at Left", @root.first_child.name, "The first child should now be the left child")
-      assert_nil(@root.last_child, "The first child is now nil")
+      assert_nil(@root.right_child, 'The right child should now be nil')
+      assert_equal('A Child at Left', @root.first_child.name, 'The first child should now be the left child')
+      assert_nil(@root.last_child, 'The first child is now nil')
     end
 
     # Test isLeft_child? method.
@@ -255,14 +255,14 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
 
-      assert(@left_child1.is_left_child?, "left_child1 should be the left child")
-      assert(!@right_child1.is_left_child?, "left_child1 should be the left child")
+      assert(@left_child1.is_left_child?, 'left_child1 should be the left child')
+      assert(!@right_child1.is_left_child?, 'left_child1 should be the left child')
 
       # Now set the right child as nil, and retest
       @root.right_child = nil
-      assert(@left_child1.is_left_child?, "left_child1 should be the left child")
+      assert(@left_child1.is_left_child?, 'left_child1 should be the left child')
 
-      assert(!@root.is_left_child?, "Root is neither left child nor right")
+      assert(!@root.is_left_child?, 'Root is neither left child nor right')
     end
 
     # Test is_right_child? method.
@@ -270,13 +270,13 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
 
-      assert(@right_child1.is_right_child?, "right_child1 should be the right child")
-      assert(!@left_child1.is_right_child?, "right_child1 should be the right child")
+      assert(@right_child1.is_right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.is_right_child?, 'right_child1 should be the right child')
 
       # Now set the left child as nil, and retest
       @root.left_child = nil
-      assert(@right_child1.is_right_child?, "right_child1 should be the right child")
-      assert(!@root.is_right_child?, "Root is neither left child nor right")
+      assert(@right_child1.is_right_child?, 'right_child1 should be the right child')
+      assert(!@root.is_right_child?, 'Root is neither left child nor right')
     end
 
     # Test swap_children method.
@@ -284,35 +284,37 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
 
-      assert(@right_child1.is_right_child?, "right_child1 should be the right child")
-      assert(!@left_child1.is_right_child?, "right_child1 should be the right child")
+      assert(@right_child1.is_right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.is_right_child?, 'right_child1 should be the right child')
 
       @root.swap_children
 
-      assert(@right_child1.is_left_child?, "right_child1 should now be the left child")
-      assert(@left_child1.is_right_child?, "left_child1 should now be the right child")
-      assert_equal(@right_child1, @root.first_child, "right_child1 should now be the first child")
-      assert_equal(@left_child1, @root.last_child, "left_child1 should now be the last child")
-      assert_equal(@right_child1, @root[0], "right_child1 should now be the first child")
-      assert_equal(@left_child1, @root[1], "left_child1 should now be the last child")
+      assert(@right_child1.is_left_child?, 'right_child1 should now be the left child')
+      assert(@left_child1.is_right_child?, 'left_child1 should now be the right child')
+      assert_equal(@right_child1, @root.first_child, 'right_child1 should now be the first child')
+      assert_equal(@left_child1, @root.last_child, 'left_child1 should now be the last child')
+      assert_equal(@right_child1, @root[0], 'right_child1 should now be the first child')
+      assert_equal(@left_child1, @root[1], 'left_child1 should now be the last child')
     end
 
     # Test the old CamelCase method names
-    def test_old_camelCase_method_names
-      @left_child2  = Tree::BinaryTreeNode.new("A Child at Left", "Child Node @ left")
-      @right_child2 = Tree::BinaryTreeNode.new("B Child at Right", "Child Node @ right")
+    def test_old_camel_case_names
+      @left_child2  = Tree::BinaryTreeNode.new('A Child at Left', 'Child Node @ left')
+      @right_child2 = Tree::BinaryTreeNode.new('B Child at Right', 'Child Node @ right')
 
       require 'structured_warnings'
 
       meth_names_for_test = %w{leftChild isLeftChild? rightChild isRightChild?}
 
       meth_names_for_test.each do |meth_name|
-        assert_warn(DeprecatedMethodWarning) {@root.send(meth_name)}
+        assert_warn(StructuredWarnings::DeprecatedMethodWarning) {@root.send(meth_name)}
       end
 
-      assert_warn(DeprecatedMethodWarning) {@root.leftChild = @left_child2}
-      assert_warn(DeprecatedMethodWarning) {@root.rightChild = @right_child2}
-      assert_raise(NoMethodError) {@root.to_snake_case("ABCD")} # Make sure the right method is visible
+      # noinspection RubyResolve
+      assert_warn(StructuredWarnings::DeprecatedMethodWarning) {@root.leftChild = @left_child2}
+      # noinspection RubyResolve
+      assert_warn(StructuredWarnings::DeprecatedMethodWarning) {@root.rightChild = @right_child2}
+      assert_raise(NoMethodError) {@root.DummyMethodDoesNotExist} # Make sure the right method is visible
 
     end
 

data/test/test_rubytree_require.rb

@@ -33,7 +33,7 @@
 #
 
 require 'test/unit'
-require 'rubytree'
+require_relative '../lib/rubytree'
 
 module TestTree
 
@@ -42,7 +42,7 @@ module TestTree
 
     # A simple test.  We are just checking whether the require worked.
     def test_create_a_simple_node
-      assert_not_nil(Tree::TreeNode.new("Root", "A Root node"))
+      assert_not_nil(Tree::TreeNode.new('Root', 'A Root node'))
     end
   end
 end

data/test/test_subclassed_node.rb

@@ -2,7 +2,7 @@
 
 # test_subclassed_node.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2012 Anupam Sengupta
+# Copyright (c) 2012, 2017 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -34,7 +34,7 @@
 
 require 'test/unit'
 require 'json'
-require 'tree'
+require_relative '../lib/tree'
 
 module TestTree
 
@@ -45,27 +45,28 @@ module TestTree
     class MyNode < Tree::TreeNode
       # A dummy method to test the camelCasedMethod resolution
       def my_dummy_method
-        "Hello"
+        'Hello'
       end
     end
 
-    def test_subclassed_camelcase_methods
-      root = MyNode.new("Root")
+    def test_camelcase_methods
+      root = MyNode.new('Root')
 
-      assert_equal("Hello", root.my_dummy_method)
+      assert_equal('Hello', root.my_dummy_method)
 
       # We should get a warning as we are invoking the camelCase version of the dummy method.
-      assert_warn(DeprecatedMethodWarning) { root.send('MyDummyMethod') }
+      assert_warn(StructuredWarnings::DeprecatedMethodWarning) { root.send('MyDummyMethod') }
 
-      # Test if the structured_warnings can be disabled to call the CamelCa
-      DeprecatedMethodWarning.disable do
-        assert_equal("Hello", root.myDummyMethod)
+      # Test if the structured_warnings can be disabled to call the CamelCase methods.
+      StructuredWarnings::DeprecatedMethodWarning.disable do
+        # noinspection RubyResolve
+        assert_equal('Hello', root.myDummyMethod)
       end
 
     end
 
-    def test_subclassed_detached_copy_is_same_class
-      root = MyNode.new("Root")
+    def test_detached_copy_same_clz
+      root = MyNode.new('Root')
       assert_equal(MyNode, root.detached_copy.class)
     end
 

data/test/test_thread_and_fiber.rb

@@ -34,7 +34,7 @@
 
 require 'test/unit'
 require 'json'
-require 'tree'
+require_relative '../lib/tree'
 
 module TestTree
   # Test class for the Tree node.
@@ -42,7 +42,7 @@ module TestTree
 
     # Test long and unbalanced trees
     def create_long_depth_trees(depth=100)
-      tree = Tree::TreeNode.new("/")
+      tree = Tree::TreeNode.new('/')
       current = tree
       depth.times do |i|
         new_node = Tree::TreeNode.new("#{i}")
@@ -50,7 +50,7 @@ module TestTree
         current = new_node
       end
 
-      tree.each { |n| nil }
+      tree.each { |_| nil }
       tree
     end