rubytree 1.0.0 → 1.0.2

data/spec/tree_spec.rb

@@ -11,7 +11,6 @@ require 'rspec'
 require 'spec_helper'
 
 describe Tree do
-
   shared_examples_for 'any detached node' do
     it 'should not equal "Object.new"' do
       expect(@tree).not_to eq(Object.new)
@@ -25,7 +24,6 @@ describe Tree do
     it 'does not have a parent node' do
       expect(@tree.parent).to eq(nil)
     end
-
   end
   context '#initialize', 'with empty name and nil content' do
     before(:each) do

data/test/test_binarytree.rb

@@ -39,7 +39,6 @@ require_relative '../lib/tree/binarytree'
 module TestTree
   # Test class for the binary tree node.
   class TestBinaryTreeNode < Test::Unit::TestCase
-
     # Setup the test data scaffolding.
     def setup
       @root = Tree::BinaryTreeNode.new('ROOT', 'Root Node')
@@ -65,15 +64,15 @@ module TestTree
 
     def test_from_hash
       # Can't make a root node without a name
-      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({})}
+      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,7 +87,7 @@ 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)
@@ -100,7 +99,7 @@ module TestTree
       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 +107,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
       #   / \
@@ -123,9 +122,9 @@ module TestTree
       assert_equal('leaf', root[:B][:D].content)
 
       # Can't add more than two children
-      assert_raise(ArgumentError) { root.add_from_hash({X: {}}) }
+      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) { node.add_from_hash({ A: {}, B: {}, C: {} }) }
     end
 
     # Test the add method.
@@ -175,24 +174,26 @@ module TestTree
       f << g
       b << d << c
       d << e
-      g.right_child = i         # This needs to be explicit
+      g.right_child = i # This needs to be explicit
       i << h
 
       # The expected order of response
       expected_array = [a, b, c, d, e, f, g, h, i]
 
       result_array = []
-      result = f.inordered_each { |node| result_array << node.detached_copy}
+      result = f.inordered_each { |node| result_array << node.detached_copy }
 
-      assert_equal(f, result)   # each should return the original object
+      assert_equal(f, result) # each should return the original object
 
       expected_array.each_index do |idx|
         # Match only the names.
         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
-      assert_equal(Enumerable::Enumerator, f.inordered_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
+      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
     end
 
     # Test the left_child method.
@@ -304,19 +305,17 @@ module TestTree
 
       require 'structured_warnings'
 
-      meth_names_for_test = %w{leftChild isLeftChild? rightChild isRightChild?}
+      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)}
+        assert_warn(StructuredWarnings::DeprecatedMethodWarning) { @root.send(meth_name) }
       end
 
       # noinspection RubyResolve
-      assert_warn(StructuredWarnings::DeprecatedMethodWarning) {@root.leftChild = @left_child2}
+      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
-
+      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

@@ -36,10 +36,8 @@ require 'test/unit'
 require_relative '../lib/rubytree'
 
 module TestTree
-
   # Test class for checking whether require 'rubytree' works.
   class TestRequireRubytree < Test::Unit::TestCase
-
     # 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'))

data/test/test_subclassed_node.rb

@@ -37,10 +37,8 @@ require 'json'
 require_relative '../lib/tree'
 
 module TestTree
-
   # Test class for the Tree node.
   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
@@ -62,14 +60,12 @@ module TestTree
         # noinspection RubyResolve
         assert_equal('Hello', root.myDummyMethod)
       end
-
     end
 
     def test_detached_copy_same_clz
       root = MyNode.new('Root')
       assert_equal(MyNode, root.detached_copy.class)
     end
-
   end
 end
 

data/test/test_thread_and_fiber.rb

@@ -39,13 +39,12 @@ require_relative '../lib/tree'
 module TestTree
   # Test class for the Tree node.
   class TestFiberAndThreadOnNode < Test::Unit::TestCase
-
     # Test long and unbalanced trees
-    def create_long_depth_trees(depth=100)
+    def create_long_depth_trees(depth = 100)
       tree = Tree::TreeNode.new('/')
       current = tree
       depth.times do |i|
-        new_node = Tree::TreeNode.new("#{i}")
+        new_node = Tree::TreeNode.new(i.to_s)
         current << new_node
         current = new_node
       end
@@ -58,30 +57,28 @@ module TestTree
     # failure for very large depths on unbalanced nodes.
     def test_fiber_for_recursion
       return unless defined?(Fiber.class) # Fibers exist only from Ruby 1.9 onwards.
+
       assert_nothing_thrown do
         Fiber.new do
-          depth = 1000             # Use a reasonably large depth, which would trip a recursive stack
+          depth = 1000 # Use a reasonably large depth, which would trip a recursive stack
           root = create_long_depth_trees(depth)
-          assert_equal(depth+1, root.size)
+          assert_equal(depth + 1, root.size)
         end.resume
       end
-
     end # test_fiber
 
     # Test the recursive methods with a thread. The stack usage is causing
     # failure for very large depths on unbalanced nodes.
     def test_thread_for_recursion
       assert_nothing_thrown do
-        depth = 1000             # Use a reasonably large depth, which would trip a recursive stack
+        depth = 1000 # Use a reasonably large depth, which would trip a recursive stack
         Thread.abort_on_exception = true
         Thread.new do
           root = create_long_depth_trees(depth)
-          assert_equal(depth+1, root.size)
+          assert_equal(depth + 1, root.size)
         end
       end
-
     end # test_thread
-
   end
 end