rubytree 1.0.2 → 2.0.0

data/spec/tree_spec.rb

@@ -3,70 +3,171 @@
 # tree_spec.rb
 #
 # Author:  Anupam Sengupta
-# Time-stamp: <2015-12-31 22:57:59 anupam>
-# Copyright (C) 2015 Anupam Sengupta <anupamsg@gmail.com>
+# Time-stamp: <2022-06-20 22:16:11 anupam>
+# Copyright (C) 2015-2022 Anupam Sengupta <anupamsg@gmail.com>
 #
+# frozen_string_literal: true
 
 require 'rspec'
 require 'spec_helper'
 
+class SpecializedTreeNode < Tree::TreeNode; end
+
 describe Tree do
   shared_examples_for 'any detached node' do
-    it 'should not equal "Object.new"' do
-      expect(@tree).not_to eq(Object.new)
+    it 'does not equal "Object.new"' do
+      expect(tree).not_to eq(Object.new)
     end
-    it 'should not equal 1 or any other fixnum' do
-      expect(@tree).not_to eq(1)
+
+    it 'does not equal 1 or any other fixnum' do
+      expect(tree).not_to eq(1)
     end
+
     it 'identifies itself as a root node' do
-      expect(@tree.is_root?).to eq(true)
+      expect(tree.root?).to be(true)
     end
+
     it 'does not have a parent node' do
-      expect(@tree.parent).to eq(nil)
+      expect(tree.parent).to be_nil
     end
   end
-  context '#initialize', 'with empty name and nil content' do
-    before(:each) do
-      @tree = Tree::TreeNode.new('')
-    end
+
+  describe '#initialize with empty name and nil content' do
+    let(:tree) { Tree::TreeNode.new('') }
+
     it 'creates the tree node with name as ""' do
-      expect(@tree.name).to eq('')
+      expect(tree.name).to eq('')
     end
+
     it "has 'nil' content" do
-      expect(@tree.content).to eq(nil)
+      expect(tree.content).to be_nil
     end
 
     it_behaves_like 'any detached node'
   end
 
-  context '#initialize', "with name 'A' and nil content" do
-    before(:each) do
-      @tree = Tree::TreeNode.new('A')
-    end
+  describe "#initialize with name 'A' and nil content" do
+    let(:tree) { Tree::TreeNode.new('A') }
 
     it 'creates the tree node with name as "A"' do
-      expect(@tree.name).to eq('A')
+      expect(tree.name).to eq('A')
     end
+
     it "has 'nil' content" do
-      expect(@tree.content).to eq(nil)
+      expect(tree.content).to be_nil
     end
 
     it_behaves_like 'any detached node'
   end
 
-  context '#initialize', "with node name 'A' and some content" do
-    before(:each) do
-      @sample = 'sample'
-      @tree = Tree::TreeNode.new('A', @sample)
-    end
+  describe "#initialize with node name 'A' and some content" do
+    sample = 'some content'
+    let(:tree) { Tree::TreeNode.new('A', sample) }
 
     it 'creates the tree node with name as "A"' do
-      expect(@tree.name).to eq('A')
+      expect(tree.name).to eq('A')
     end
-    it "has some content #{@sample}" do
-      expect(@tree.content).to eq(@sample)
+
+    it "has some content #{sample}" do
+      expect(tree.content).to eq(sample)
     end
 
     it_behaves_like 'any detached node'
   end
+
+  describe 'comparison' do
+    let(:node1) { Tree::TreeNode.new('a') }
+    let(:node2) { SpecializedTreeNode.new('b') }
+
+    it 'allows comparison of specialized tree nodes' do
+      expect(node1 <=> node2).to be_eql(-1)
+    end
+
+    it 'does not allow comparison with nil' do
+      expect(node1 <=> nil).to be_nil
+    end
+
+    it 'does not allow comparison with other objects' do
+      expect(node1 <=> 'c').to be_nil
+    end
+  end
+
+  describe 'serialization' do
+    let(:serialized_node1) { Marshal.dump(SpecializedTreeNode.new('a')) }
+    let(:serialized_node2) { Marshal.dump(Tree::TreeNode.new('b')) }
+    let(:tree) do
+      SpecializedTreeNode.new('root').tap do |root|
+        root << SpecializedTreeNode.new('a')
+        root << Tree::TreeNode.new('b')
+      end
+    end
+    let(:serialized_tree) { Marshal.dump(tree) }
+
+    it 'parses the serialized specialized tree node correctly (root)' do
+      expect(Marshal.load(serialized_tree)).to be_a(SpecializedTreeNode)
+    end
+
+    it 'parses the serialized specialized tree node correctly (child)' do
+      expect(Marshal.load(serialized_tree).children.first).to \
+        be_a(SpecializedTreeNode)
+    end
+
+    it 'parses the serialized tree node correctly' do
+      expect(Marshal.load(serialized_node2)).to be_a(Tree::TreeNode)
+    end
+  end
+
+  shared_examples_for 'any cloned node' do
+    it 'is equal to the original' do
+      expect(clone).to eq tree
+    end
+
+    it 'is not identical to the original' do
+      expect(clone).not_to be tree
+    end
+  end
+
+  describe '#detached_copy', 'Without content' do
+    let(:tree) { Tree::TreeNode.new('A', nil) }
+    let(:clone) { tree.detached_copy }
+
+    it_behaves_like 'any cloned node'
+  end
+
+  describe '#detached_copy with clonable content' do
+    let(:tree) { Tree::TreeNode.new('A', 'clonable content') }
+    let(:clone) { tree.detached_copy }
+
+    it 'makes a clone of the content' do
+      expect(clone.content).to eq tree.content
+    end
+
+    it 'is not the same as the original content' do
+      expect(clone.content).not_to be tree.content
+    end
+
+    it_behaves_like 'any cloned node'
+  end
+
+  describe '#detached_copy with unclonable content' do
+    let(:tree) { Tree::TreeNode.new('A', :unclonable_content) }
+    let(:clone) { tree.detached_copy }
+
+    it 'retains the original content' do
+      expect(clone.content).to be tree.content
+    end
+
+    it_behaves_like 'any cloned node'
+  end
+
+  describe '#detached_copy with false as content' do
+    let(:tree) { Tree::TreeNode.new('A', false) }
+    let(:clone) { tree.detached_copy }
+
+    it 'retains the original content' do
+      expect(clone.content).to be tree.content
+    end
+
+    it_behaves_like 'any cloned node'
+  end
 end

data/test/run_test.rb

@@ -3,8 +3,8 @@
 # run_test.rb:: Run all the tests from the Ruby command line.
 #
 # Author:  Anupam Sengupta
-# Time-stamp: <2014-01-03 21:15:37 anupam>
-# Copyright (C) 2014 Anupam Sengupta <anupamsg@gmail.com>
+# Time-stamp: <2022-06-19 22:44:56 anupam>
+# Copyright (C) 2014, 2022 Anupam Sengupta <anupamsg@gmail.com>
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -31,6 +31,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 lib_dir  = File.join(base_dir, 'lib')
@@ -51,7 +52,7 @@ if ENV['COVERAGE']
       add_group 'Internal Utilities', '/lib/tree/utils/.*.rb'
     end
   rescue LoadError => e
-    puts 'Could not load simplecov; continuing without code coverage' + e.cause
+    puts "Could not load simplecov; continuing without code coverage #{e.cause}"
   end
 end
 

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, 2017 Anupam Sengupta
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012, 2013, 2015, 2017, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -32,6 +32,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 require 'test/unit'
 require_relative '../lib/tree/binarytree'
@@ -82,8 +83,8 @@ module TestTree
 
       assert_same(tree.class, Tree::BinaryTreeNode)
       assert_same(:A, tree.name)
-      assert_equal(true, tree.is_root?)
-      assert_equal(false, tree.is_leaf?)
+      assert_equal(true, tree.root?)
+      assert_equal(false, tree.leaf?)
       assert_equal(2, tree.children.count) # B, C, D
       assert_equal(4, tree.size)
 
@@ -130,13 +131,13 @@ module TestTree
     # 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.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')
 
       @root.add @right_child1
-      assert(!@right_child1.is_root?, 'Right child1 cannot be a root after addition to the ROOT node')
+      assert(!@right_child1.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')
@@ -191,9 +192,8 @@ module TestTree
       end
 
       assert_equal(Enumerator, f.inordered_each.class) if defined?(Enumerator.class) # Without a block
-      if defined?(Enumerable::Enumerator.class)
-        assert_equal(Enumerable::Enumerator, f.inordered_each.class)
-      end # Without a block
+
+      assert_equal(Enumerable::Enumerator, f.inordered_each.class) if defined?(Enumerable::Enumerator.class)
     end
 
     # Test the left_child method.
@@ -217,10 +217,10 @@ 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.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(!@root.left_child.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')
 
@@ -236,10 +236,10 @@ 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.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(!@root.right_child.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')
@@ -256,28 +256,28 @@ 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.left_child?, 'left_child1 should be the left child')
+      assert(!@right_child1.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.left_child?, 'left_child1 should be the left child')
 
-      assert(!@root.is_left_child?, 'Root is neither left child nor right')
+      assert(!@root.left_child?, 'Root is neither left child nor right')
     end
 
-    # Test is_right_child? method.
+    # Test right_child? method.
     def test_is_right_child_eh
       @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.right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.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.right_child?, 'right_child1 should be the right child')
+      assert(!@root.right_child?, 'Root is neither left child nor right')
     end
 
     # Test swap_children method.
@@ -285,37 +285,17 @@ 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.right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.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(@right_child1.left_child?, 'right_child1 should now be the left child')
+      assert(@left_child1.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_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(StructuredWarnings::DeprecatedMethodWarning) { @root.send(meth_name) }
-      end
-
-      # 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
   end
 end

data/test/test_rubytree_require.rb

@@ -2,7 +2,7 @@
 
 # test_rubytree_require.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2012 Anupam Sengupta
+# Copyright (c) 2012, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -31,6 +31,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 require 'test/unit'
 require_relative '../lib/rubytree'

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, 2017 Anupam Sengupta
+# Copyright (c) 2012, 2017, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -31,6 +31,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 require 'test/unit'
 require 'json'
@@ -41,25 +42,6 @@ module TestTree
   class TestSubclassedTreeNode < Test::Unit::TestCase
     # A subclassed node to test various inheritance related features.
     class MyNode < Tree::TreeNode
-      # A dummy method to test the camelCasedMethod resolution
-      def my_dummy_method
-        'Hello'
-      end
-    end
-
-    def test_camelcase_methods
-      root = MyNode.new('Root')
-
-      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(StructuredWarnings::DeprecatedMethodWarning) { root.send('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_detached_copy_same_clz

data/test/test_thread_and_fiber.rb

@@ -2,7 +2,7 @@
 
 # test_thread_and_fiber.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2012, 2013 Anupam Sengupta
+# Copyright (c) 2012, 2013, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -31,6 +31,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 require 'test/unit'
 require 'json'
@@ -49,7 +50,6 @@ module TestTree
         current = new_node
       end
 
-      tree.each { |_| nil }
       tree
     end
 
@@ -65,7 +65,7 @@ module TestTree
           assert_equal(depth + 1, root.size)
         end.resume
       end
-    end # test_fiber
+    end
 
     # Test the recursive methods with a thread. The stack usage is causing
     # failure for very large depths on unbalanced nodes.
@@ -78,7 +78,7 @@ module TestTree
           assert_equal(depth + 1, root.size)
         end
       end
-    end # test_thread
+    end
   end
 end