closure_tree 4.6.2 → 4.6.3

data/spec/matcher_spec.rb

@@ -3,29 +3,31 @@ require 'spec_helper'
 describe 'ClosureTree::Test::Matcher' do
 
   describe 'be_a_closure_tree' do
-    it { UUIDTag.should be_a_closure_tree }
-    it { User.should be_a_closure_tree }
-    it { Label.should be_a_closure_tree.ordered }
-    it { Metal.should be_a_closure_tree.ordered(:sort_order) }
-    it { MenuItem.should be_a_closure_tree }
-    it { Contract.should_not be_a_closure_tree }
+    it { expect(UUIDTag).to be_a_closure_tree }
+    it { expect(User).to be_a_closure_tree }
+    it { expect(Label).to be_a_closure_tree.ordered }
+    it { expect(Metal).to be_a_closure_tree.ordered(:sort_order) }
+    it { expect(MenuItem).to be_a_closure_tree }
+    it { expect(Contract).not_to be_a_closure_tree }
   end
 
   describe 'ordered' do
-    it { Label.should be_a_closure_tree.ordered }
-    it { UUIDTag.should be_a_closure_tree.ordered }
-    it { Metal.should be_a_closure_tree.ordered(:sort_order) }
+    it { expect(Label).to be_a_closure_tree.ordered }
+    it { expect(UUIDTag).to be_a_closure_tree.ordered }
+    it { expect(Metal).to be_a_closure_tree.ordered(:sort_order) }
   end
 
   describe 'advisory_lock' do
     it 'should use advisory lock' do
-      User.should be_a_closure_tree.with_advisory_lock
-      Label.should be_a_closure_tree.ordered.with_advisory_lock
-      Metal.should be_a_closure_tree.ordered(:sort_order).with_advisory_lock
+      expect(User).to be_a_closure_tree.with_advisory_lock
+      expect(Label).to be_a_closure_tree.ordered.with_advisory_lock
+      expect(Metal).to be_a_closure_tree.ordered(:sort_order).with_advisory_lock
     end
 
-    it 'should not use advisory lock' do
-      MenuItem.should be_a_closure_tree.without_advisory_lock
+    describe MenuItem do
+      it 'should not use advisory lock' do
+        is_expected.to be_a_closure_tree.without_advisory_lock
+      end
     end
   end
 

data/spec/metal_spec.rb

@@ -4,6 +4,6 @@ describe Metal do
   it "creates" do
     s = Metal.create(:value => 'System')
     s.reload
-    s.should_not be_new_record
+    expect(s).not_to be_new_record
   end
 end

data/spec/namespace_type_spec.rb

@@ -4,9 +4,9 @@ describe Namespace::Type do
 
   context "class injection" do
     it "should build hierarchy classname correctly" do
-      Namespace::Type.hierarchy_class.to_s.should == "Namespace::TypeHierarchy"
-      Namespace::Type._ct.hierarchy_class_name.should == "Namespace::TypeHierarchy"
-      Namespace::Type._ct.short_hierarchy_class_name.should == "TypeHierarchy"
+      expect(Namespace::Type.hierarchy_class.to_s).to eq("Namespace::TypeHierarchy")
+      expect(Namespace::Type._ct.hierarchy_class_name).to eq("Namespace::TypeHierarchy")
+      expect(Namespace::Type._ct.short_hierarchy_class_name).to eq("TypeHierarchy")
     end
   end
 

data/spec/parallel_spec.rb

@@ -58,28 +58,28 @@ describe 'Concurrent creation', if: support_concurrency do
 
   it 'will not create dupes from class methods' do
     run_workers
-    Tag.roots.collect { |ea| ea.name }.should =~ @names
+    expect(Tag.roots.collect { |ea| ea.name }).to match_array(@names)
     # No dupe children:
     %w(a b c).each do |ea|
-      Tag.where(name: ea).size.should == @iterations
+      expect(Tag.where(name: ea).size).to eq(@iterations)
     end
   end
 
   it 'will not create dupes from instance methods' do
     @target = Tag.create!(name: 'root')
     run_workers
-    @target.reload.children.collect { |ea| ea.name }.should =~ @names
-    Tag.where(name: @names).size.should == @iterations
+    expect(@target.reload.children.collect { |ea| ea.name }).to match_array(@names)
+    expect(Tag.where(name: @names).size).to eq(@iterations)
     %w(a b c).each do |ea|
-      Tag.where(name: ea).size.should == @iterations
+      expect(Tag.where(name: ea).size).to eq(@iterations)
     end
   end
 
   it 'creates dupe roots without advisory locks' do
     # disable with_advisory_lock:
-    Tag.stub(:with_advisory_lock).and_return { |_lock_name, &block| block.call }
+    allow(Tag).to receive(:with_advisory_lock) { |_lock_name, &block| block.call }
     run_workers
-    Tag.where(name: @names).size.should > @iterations
+    expect(Tag.where(name: @names).size).to be > @iterations
   end
 
   class SiblingPrependerWorker < WorkerBase
@@ -133,8 +133,8 @@ describe 'Concurrent creation', if: support_concurrency do
     creator_threads.each { |ea| ea.join }
     run_destruction = false
     destroyer_threads.each { |ea| ea.join }
-    added_children.should =~ expected_children
-    deleted_children.should =~ expected_children
+    expect(added_children).to match(expected_children)
+    expect(deleted_children).to match(expected_children)
   end
 
   xit 'fails to deadlock while simultaneously deleting items from the same hierarchy' do
@@ -149,7 +149,7 @@ describe 'Concurrent creation', if: support_concurrency do
       end
     end
     destroyer_threads.each { |ea| ea.join }
-    User.all.should be_empty
+    expect(User.all).to be_empty
   end
 
   class SiblingPrependerWorker < WorkerBase
@@ -168,10 +168,10 @@ describe 'Concurrent creation', if: support_concurrency do
     run_workers(SiblingPrependerWorker)
     children = Label.roots
     uniq_order_values = children.collect { |ea| ea.order_value }.uniq
-    children.size.should == uniq_order_values.size
+    expect(children.size).to eq(uniq_order_values.size)
 
     # The only non-root node should be "root":
-    Label.all.select { |ea| ea.root? }.should == [@target.parent]
+    expect(Label.all.select { |ea| ea.root? }).to eq([@target.parent])
   end
 
 end

data/spec/support_spec.rb

@@ -4,11 +4,11 @@ describe ClosureTree::Support do
   let(:sut) { Tag._ct }
   it 'passes through table names without prefix and suffix' do
     expected = 'some_random_table_name'
-    sut.remove_prefix_and_suffix(expected).should == expected
+    expect(sut.remove_prefix_and_suffix(expected)).to eq(expected)
   end
   it 'extracts through table name with prefix and suffix' do
     expected = 'some_random_table_name'
     tn = ActiveRecord::Base.table_name_prefix + expected + ActiveRecord::Base.table_name_suffix
-    sut.remove_prefix_and_suffix(tn).should == expected
+    expect(sut.remove_prefix_and_suffix(tn)).to eq(expected)
   end
 end

data/spec/tag_examples.rb

@@ -9,19 +9,19 @@ shared_examples_for Tag do
 
     it 'has correct accessible_attributes' do
       if tag_class._ct.use_attr_accessible?
-        tag_class.accessible_attributes.to_a.should =~ %w(parent name title)
+        expect(tag_class.accessible_attributes.to_a).to match_array(%w(parent name title))
       end
     end
 
     it 'should build hierarchy classname correctly' do
-      tag_class.hierarchy_class.should == tag_hierarchy_class
-      tag_class._ct.hierarchy_class_name.should == tag_hierarchy_class.to_s
-      tag_class._ct.short_hierarchy_class_name.should == tag_hierarchy_class.to_s
+      expect(tag_class.hierarchy_class).to eq(tag_hierarchy_class)
+      expect(tag_class._ct.hierarchy_class_name).to eq(tag_hierarchy_class.to_s)
+      expect(tag_class._ct.short_hierarchy_class_name).to eq(tag_hierarchy_class.to_s)
     end
 
     it 'should have a correct parent column name' do
       expected_parent_column_name = tag_class == UUIDTag ? "parent_uuid" : "parent_id"
-      tag_class._ct.parent_column_name.should == expected_parent_column_name
+      expect(tag_class._ct.parent_column_name).to eq(expected_parent_column_name)
     end
   end
 
@@ -29,13 +29,13 @@ shared_examples_for Tag do
 
     context "with no tags" do
       it "should return no entities" do
-        tag_class.roots.should be_empty
-        tag_class.leaves.should be_empty
+        expect(tag_class.roots).to be_empty
+        expect(tag_class.leaves).to be_empty
       end
 
       it "#find_or_create_by_path" do
         a = tag_class.create!(:name => 'a')
-        a.find_or_create_by_path(%w{b c}).ancestry_path.should == %w{a b c}
+        expect(a.find_or_create_by_path(%w{b c}).ancestry_path).to eq(%w{a b c})
       end
     end
 
@@ -45,21 +45,21 @@ shared_examples_for Tag do
       end
 
       it "should be a leaf" do
-        @tag.leaf?.should be_true
+        expect(@tag.leaf?).to be_truthy
       end
 
       it "should be a root" do
-        @tag.root?.should be_true
+        expect(@tag.root?).to be_truthy
       end
 
       it 'has no parent' do
-        @tag.parent.should be_nil
+        expect(@tag.parent).to be_nil
       end
 
       it "should return the only entity as a root and leaf" do
-        tag_class.all.should == [@tag]
-        tag_class.roots.should == [@tag]
-        tag_class.leaves.should == [@tag]
+        expect(tag_class.all).to eq([@tag])
+        expect(tag_class.roots).to eq([@tag])
+        expect(tag_class.leaves).to eq([@tag])
       end
 
       context "with child" do
@@ -68,16 +68,16 @@ shared_examples_for Tag do
         end
 
         def assert_roots_and_leaves
-          @tag.root?.should be_true
-          @tag.leaf?.should be_false
+          expect(@tag.root?).to be_truthy
+          expect(@tag.leaf?).to be_falsey
 
-          @child.root?.should be_false
-          @child.leaf?.should be_true
+          expect(@child.root?).to be_falsey
+          expect(@child.leaf?).to be_truthy
         end
 
         def assert_parent_and_children
-          @child.reload.parent.should == @tag
-          @tag.reload.children.to_a.should == [@child]
+          expect(@child.reload.parent).to eq(@tag)
+          expect(@tag.reload.children.to_a).to eq([@child])
         end
 
         it "adds children through add_child" do
@@ -100,15 +100,15 @@ shared_examples_for Tag do
         @leaf = @root.add_child(tag_class.create!(:name => "leaf"))
       end
       it "should return a simple root and leaf" do
-        tag_class.roots.should == [@root]
-        tag_class.leaves.should == [@leaf]
+        expect(tag_class.roots).to eq([@root])
+        expect(tag_class.leaves).to eq([@leaf])
       end
       it "should return child_ids for root" do
-        @root.child_ids.should == [@leaf.id]
+        expect(@root.child_ids).to eq([@leaf.id])
       end
 
       it "should return an empty array for leaves" do
-        @leaf.child_ids.should be_empty
+        expect(@leaf.child_ids).to be_empty
       end
     end
 
@@ -121,55 +121,55 @@ shared_examples_for Tag do
       end
 
       it "should create all tags" do
-        tag_class.all.to_a.should =~ [@root, @mid, @leaf]
+        expect(tag_class.all.to_a).to match_array([@root, @mid, @leaf])
       end
 
       it "should return a root and leaf without middle tag" do
-        tag_class.roots.should == [@root]
-        tag_class.leaves.should == [@leaf]
+        expect(tag_class.roots).to eq([@root])
+        expect(tag_class.leaves).to eq([@leaf])
       end
 
       it "should delete leaves" do
         tag_class.leaves.destroy_all
-        tag_class.roots.should == [@root] # untouched
-        tag_class.leaves.should == [@mid]
+        expect(tag_class.roots).to eq([@root]) # untouched
+        expect(tag_class.leaves).to eq([@mid])
       end
 
       it "should delete everything if you delete the roots" do
         tag_class.roots.destroy_all
-        tag_class.all.should be_empty
-        tag_class.roots.should be_empty
-        tag_class.leaves.should be_empty
-        DestroyedTag.all.map { |t| t.name }.should =~ %w{root mid leaf}
+        expect(tag_class.all).to be_empty
+        expect(tag_class.roots).to be_empty
+        expect(tag_class.leaves).to be_empty
+        expect(DestroyedTag.all.map { |t| t.name }).to match_array(%w{root mid leaf})
       end
 
       it 'fix self_and_ancestors properly on reparenting' do
         t = tag_class.create! :name => 'moar leaf'
-        t.self_and_ancestors.to_a.should == [t]
+        expect(t.self_and_ancestors.to_a).to eq([t])
         @mid.children << t
-        t.self_and_ancestors.to_a.should == [t, @mid, @root]
+        expect(t.self_and_ancestors.to_a).to eq([t, @mid, @root])
       end
 
       it 'prevents ancestor loops' do
         @leaf.add_child @root
-        @root.should_not be_valid
-        @root.reload.descendants.should include(@leaf)
+        expect(@root).not_to be_valid
+        expect(@root.reload.descendants).to include(@leaf)
       end
 
       it 'moves non-leaves' do
         new_root = tag_class.create! :name => "new_root"
         new_root.children << @mid
-        @root.reload.descendants.should be_empty
-        new_root.descendants.should == [@mid, @leaf]
-        @leaf.reload.ancestry_path.should == %w{new_root mid leaf}
+        expect(@root.reload.descendants).to be_empty
+        expect(new_root.descendants).to eq([@mid, @leaf])
+        expect(@leaf.reload.ancestry_path).to eq(%w{new_root mid leaf})
       end
 
       it 'moves leaves' do
         new_root = tag_class.create! :name => "new_root"
         new_root.children << @leaf
-        new_root.descendants.should == [@leaf]
-        @root.reload.descendants.should == [@mid]
-        @leaf.reload.ancestry_path.should == %w{new_root leaf}
+        expect(new_root.descendants).to eq([@leaf])
+        expect(@root.reload.descendants).to eq([@mid])
+        expect(@leaf.reload.ancestry_path).to eq(%w{new_root leaf})
       end
     end
 
@@ -181,55 +181,55 @@ shared_examples_for Tag do
       end
 
       it "should create all tags" do
-        tag_class.all.to_a.should =~ [@root, @mid, @leaf]
+        expect(tag_class.all.to_a).to match_array([@root, @mid, @leaf])
       end
 
       it "should return a root and leaf without middle tag" do
-        tag_class.roots.should == [@root]
-        tag_class.leaves.should == [@leaf]
+        expect(tag_class.roots).to eq([@root])
+        expect(tag_class.leaves).to eq([@leaf])
       end
 
       it "should prevent parental loops from torso" do
         @mid.children << @root
-        @root.valid?.should be_false
-        @mid.reload.children.should == [@leaf]
+        expect(@root.valid?).to be_falsey
+        expect(@mid.reload.children).to eq([@leaf])
       end
 
       it "should prevent parental loops from toes" do
         @leaf.children << @root
-        @root.valid?.should be_false
-        @leaf.reload.children.should be_empty
+        expect(@root.valid?).to be_falsey
+        expect(@leaf.reload.children).to be_empty
       end
 
       it "should support re-parenting" do
         @root.children << @leaf
-        tag_class.leaves.should == [@leaf, @mid]
+        expect(tag_class.leaves).to eq([@leaf, @mid])
       end
 
       it "cleans up hierarchy references for leaves" do
         @leaf.destroy
-        tag_hierarchy_class.where(:ancestor_id => @leaf.id).should be_empty
-        tag_hierarchy_class.where(:descendant_id => @leaf.id).should be_empty
+        expect(tag_hierarchy_class.where(:ancestor_id => @leaf.id)).to be_empty
+        expect(tag_hierarchy_class.where(:descendant_id => @leaf.id)).to be_empty
       end
 
       it "cleans up hierarchy references" do
         @mid.destroy
-        tag_hierarchy_class.where(:ancestor_id => @mid.id).should be_empty
-        tag_hierarchy_class.where(:descendant_id => @mid.id).should be_empty
-        @root.reload.should be_root
+        expect(tag_hierarchy_class.where(:ancestor_id => @mid.id)).to be_empty
+        expect(tag_hierarchy_class.where(:descendant_id => @mid.id)).to be_empty
+        expect(@root.reload).to be_root
         root_hiers = @root.ancestor_hierarchies.to_a
-        root_hiers.size.should == 1
-        tag_hierarchy_class.where(:ancestor_id => @root.id).should == root_hiers
-        tag_hierarchy_class.where(:descendant_id => @root.id).should == root_hiers
+        expect(root_hiers.size).to eq(1)
+        expect(tag_hierarchy_class.where(:ancestor_id => @root.id)).to eq(root_hiers)
+        expect(tag_hierarchy_class.where(:descendant_id => @root.id)).to eq(root_hiers)
       end
 
       it "should have different hash codes for each hierarchy model" do
         hashes = tag_hierarchy_class.all.map(&:hash)
-        hashes.should =~ hashes.uniq
+        expect(hashes).to match_array(hashes.uniq)
       end
 
       it "should return the same hash code for equal hierarchy models" do
-        tag_hierarchy_class.first.hash.should == tag_hierarchy_class.first.hash
+        expect(tag_hierarchy_class.first.hash).to eq(tag_hierarchy_class.first.hash)
       end
     end
 
@@ -241,23 +241,26 @@ shared_examples_for Tag do
       parent.children << child2
       child3 = tag_class.new(:name => 'Third Child')
       parent.add_child child3
-      grandparent.self_and_descendants.collect(&:name).should ==
+      expect(grandparent.self_and_descendants.collect(&:name)).to eq(
         ["Grandparent", "Parent", "First Child", "Second Child", "Third Child"]
-      child1.ancestry_path.should ==
+      )
+      expect(child1.ancestry_path).to eq(
         ["Grandparent", "Parent", "First Child"]
-      child3.ancestry_path.should ==
+      )
+      expect(child3.ancestry_path).to eq(
         ["Grandparent", "Parent", "Third Child"]
+      )
       d = tag_class.find_or_create_by_path %w(a b c d)
       h = tag_class.find_or_create_by_path %w(e f g h)
       e = h.root
       d.add_child(e) # "d.children << e" would work too, of course
-      h.ancestry_path.should == %w(a b c d e f g h)
+      expect(h.ancestry_path).to eq(%w(a b c d e f g h))
     end
 
     it "roots sort alphabetically" do
       expected = ("a".."z").to_a
       expected.shuffle.each { |ea| tag_class.create!(:name => ea) }
-      tag_class.roots.collect { |ea| ea.name }.should == expected
+      expect(tag_class.roots.collect { |ea| ea.name }).to eq(expected)
     end
 
     context "with simple tree" do
@@ -279,32 +282,32 @@ shared_examples_for Tag do
       end
 
       it 'should find global roots' do
-        tag_class.roots.to_a.should =~ @expected_roots
+        expect(tag_class.roots.to_a).to match_array(@expected_roots)
       end
       it 'should return root? for roots' do
-        @expected_roots.each { |ea| ea.should be_root }
+        @expected_roots.each { |ea| expect(ea).to be_root }
       end
       it 'should not return root? for non-roots' do
-        [@b1, @b2, @c1a, @c1b].each { |ea| ea.should_not be_root }
+        [@b1, @b2, @c1a, @c1b].each { |ea| expect(ea).not_to be_root }
       end
       it 'should return the correct root' do
         {@a1 => @a1, @a2 => @a2, @a3 => @a3,
           @b1 => @a1, @b2 => @a2, @c1a => @a1, @c1b => @a1}.each do |node, root|
-          node.root.should == root
+          expect(node.root).to eq(root)
         end
       end
       it 'should assemble global leaves' do
-        tag_class.leaves.to_a.should =~ @expected_leaves
+        expect(tag_class.leaves.to_a).to match_array(@expected_leaves)
       end
       it 'assembles siblings properly' do
         @expected_siblings.each do |siblings|
           siblings.each do |ea|
-            ea.self_and_siblings.to_a.should =~ siblings
-            ea.siblings.to_a.should =~ siblings - [ea]
+            expect(ea.self_and_siblings.to_a).to match_array(siblings)
+            expect(ea.siblings.to_a).to match_array(siblings - [ea])
           end
         end
         @expected_only_children.each do |ea|
-          ea.siblings.should == []
+          expect(ea.siblings).to eq([])
         end
       end
       it 'assembles before_siblings' do
@@ -312,7 +315,7 @@ shared_examples_for Tag do
           (siblings.size - 1).times do |i|
             target = siblings[i]
             expected_before = siblings.first(i)
-            target.siblings_before.to_a.should == expected_before
+            expect(target.siblings_before.to_a).to eq(expected_before)
           end
         end
       end
@@ -321,49 +324,49 @@ shared_examples_for Tag do
           (siblings.size - 1).times do |i|
             target = siblings[i]
             expected_after = siblings.last(siblings.size - 1 - i)
-            target.siblings_after.to_a.should == expected_after
+            expect(target.siblings_after.to_a).to eq(expected_after)
           end
         end
       end
       it 'should assemble instance leaves' do
         {@a1 => [@b1b, @c1a, @c1b, @c1c], @b1 => [@c1a, @c1b, @c1c], @a2 => [@b2]}.each do |node, leaves|
-          node.leaves.to_a.should == leaves
+          expect(node.leaves.to_a).to eq(leaves)
         end
-        @expected_leaves.each { |ea| ea.leaves.to_a.should == [ea] }
+        @expected_leaves.each { |ea| expect(ea.leaves.to_a).to eq([ea]) }
       end
       it 'should return leaf? for leaves' do
-        @expected_leaves.each { |ea| ea.should be_leaf }
+        @expected_leaves.each { |ea| expect(ea).to be_leaf }
       end
 
       it 'can move roots' do
         @c1a.children << @a2
         @b2.reload.children << @a3
-        @a3.reload.ancestry_path.should ==%w(a1 b1 c1a a2 b2 a3)
+        expect(@a3.reload.ancestry_path).to eq(%w(a1 b1 c1a a2 b2 a3))
       end
 
       it 'cascade-deletes from roots' do
         victim_names = @a1.self_and_descendants.map(&:name)
         survivor_names = tag_class.all.map(&:name) - victim_names
         @a1.destroy
-        tag_class.all.map(&:name).should == survivor_names
+        expect(tag_class.all.map(&:name)).to eq(survivor_names)
       end
     end
 
     context 'with_ancestor' do
       it 'works with no rows' do
-        tag_class.with_ancestor.to_a.should be_empty
+        expect(tag_class.with_ancestor.to_a).to be_empty
       end
       it 'finds only children' do
         c = tag_class.find_or_create_by_path %w(A B C)
         a, b = c.parent.parent, c.parent
         spurious_tags = tag_class.find_or_create_by_path %w(D E)
-        tag_class.with_ancestor(a).to_a.should == [b, c]
+        expect(tag_class.with_ancestor(a).to_a).to eq([b, c])
       end
       it 'limits subsequent where clauses' do
         a1c = tag_class.find_or_create_by_path %w(A1 B C)
         a2c = tag_class.find_or_create_by_path %w(A2 B C)
-        tag_class.where(:name => "C").to_a.should =~ [a1c, a2c]
-        tag_class.with_ancestor(a1c.parent.parent).where(:name => "C").to_a.should == [a1c]
+        expect(tag_class.where(:name => "C").to_a).to match_array([a1c, a2c])
+        expect(tag_class.with_ancestor(a1c.parent.parent).where(:name => "C").to_a).to eq([a1c])
       end
     end
 
@@ -379,65 +382,65 @@ shared_examples_for Tag do
       end
 
       it "should build ancestry path" do
-        @child.ancestry_path.should == %w{grandparent parent child}
-        @child.ancestry_path(:name).should == %w{grandparent parent child}
-        @child.ancestry_path(:title).should == %w{Nonnie Mom Kid}
+        expect(@child.ancestry_path).to eq(%w{grandparent parent child})
+        expect(@child.ancestry_path(:name)).to eq(%w{grandparent parent child})
+        expect(@child.ancestry_path(:title)).to eq(%w{Nonnie Mom Kid})
       end
 
       it 'assembles ancestors' do
-        @child.ancestors.should == [@parent, @grandparent]
-        @child.self_and_ancestors.should == [@child, @parent, @grandparent]
+        expect(@child.ancestors).to eq([@parent, @grandparent])
+        expect(@child.self_and_ancestors).to eq([@child, @parent, @grandparent])
       end
 
       it "should find by path" do
         # class method:
-        tag_class.find_by_path(%w{grandparent parent child}).should == @child
+        expect(tag_class.find_by_path(%w{grandparent parent child})).to eq(@child)
         # instance method:
-        @parent.find_by_path(%w{child}).should == @child
-        @grandparent.find_by_path(%w{parent child}).should == @child
-        @parent.find_by_path(%w{child larvae}).should be_nil
+        expect(@parent.find_by_path(%w{child})).to eq(@child)
+        expect(@grandparent.find_by_path(%w{parent child})).to eq(@child)
+        expect(@parent.find_by_path(%w{child larvae})).to be_nil
       end
 
       it "finds correctly rooted paths" do
         decoy = tag_class.find_or_create_by_path %w(a b c d)
         b_d = tag_class.find_or_create_by_path %w(b c d)
-        tag_class.find_by_path(%w(b c d)).should == b_d
-        tag_class.find_by_path(%w(c d)).should be_nil
+        expect(tag_class.find_by_path(%w(b c d))).to eq(b_d)
+        expect(tag_class.find_by_path(%w(c d))).to be_nil
       end
 
       it "find_by_path for 1 node" do
         b = tag_class.find_or_create_by_path %w(a b)
         b2 = b.root.find_by_path(%w(b))
-        b2.should == b
+        expect(b2).to eq(b)
       end
 
       it "find_by_path for 2 nodes" do
         c = tag_class.find_or_create_by_path %w(a b c)
-        c.root.find_by_path(%w(b c)).should == c
-        c.root.find_by_path(%w(a c)).should be_nil
-        c.root.find_by_path(%w(c)).should be_nil
+        expect(c.root.find_by_path(%w(b c))).to eq(c)
+        expect(c.root.find_by_path(%w(a c))).to be_nil
+        expect(c.root.find_by_path(%w(c))).to be_nil
       end
 
       it "find_by_path for 3 nodes" do
         d = tag_class.find_or_create_by_path %w(a b c d)
-        d.root.find_by_path(%w(b c d)).should == d
-        tag_class.find_by_path(%w(a b c d)).should == d
-        tag_class.find_by_path(%w(d)).should be_nil
+        expect(d.root.find_by_path(%w(b c d))).to eq(d)
+        expect(tag_class.find_by_path(%w(a b c d))).to eq(d)
+        expect(tag_class.find_by_path(%w(d))).to be_nil
       end
 
       it "should return nil for missing nodes" do
-        tag_class.find_by_path(%w{missing}).should be_nil
-        tag_class.find_by_path(%w{grandparent missing}).should be_nil
-        tag_class.find_by_path(%w{grandparent parent missing}).should be_nil
-        tag_class.find_by_path(%w{grandparent parent missing child}).should be_nil
+        expect(tag_class.find_by_path(%w{missing})).to be_nil
+        expect(tag_class.find_by_path(%w{grandparent missing})).to be_nil
+        expect(tag_class.find_by_path(%w{grandparent parent missing})).to be_nil
+        expect(tag_class.find_by_path(%w{grandparent parent missing child})).to be_nil
       end
 
       it ".find_or_create_by_path" do
         grandparent = tag_class.find_or_create_by_path(%w{grandparent})
-        grandparent.should == @grandparent
+        expect(grandparent).to eq(@grandparent)
         child = tag_class.find_or_create_by_path(%w{grandparent parent child})
-        child.should == @child
-        tag_class.find_or_create_by_path(%w{events anniversary}).ancestry_path.should == %w{events anniversary}
+        expect(child).to eq(@child)
+        expect(tag_class.find_or_create_by_path(%w{events anniversary}).ancestry_path).to eq(%w{events anniversary})
       end
 
       it "should respect attribute hashes with both selection and creation" do
@@ -445,18 +448,18 @@ shared_examples_for Tag do
         attrs = {:title => expected_title}
         existing_title = @grandparent.title
         new_grandparent = tag_class.find_or_create_by_path(%w{grandparent}, attrs)
-        new_grandparent.should_not == @grandparent
-        new_grandparent.title.should == expected_title
-        @grandparent.reload.title.should == existing_title
+        expect(new_grandparent).not_to eq(@grandparent)
+        expect(new_grandparent.title).to eq(expected_title)
+        expect(@grandparent.reload.title).to eq(existing_title)
       end
 
       it "should create a hierarchy with a given attribute" do
         expected_title = 'unicorn rainbows'
         attrs = {:title => expected_title}
         child = tag_class.find_or_create_by_path(%w{grandparent parent child}, attrs)
-        child.should_not == @child
+        expect(child).not_to eq(@child)
         [child, child.parent, child.parent.parent].each do |ea|
-          ea.title.should == expected_title
+          expect(ea.title).to eq(expected_title)
         end
       end
     end
@@ -477,22 +480,22 @@ shared_examples_for Tag do
 
       context "#hash_tree" do
         it "returns {} for depth 0" do
-          tag_class.hash_tree(:limit_depth => 0).should == {}
+          expect(tag_class.hash_tree(:limit_depth => 0)).to eq({})
         end
         it "limit_depth 1" do
-          tag_class.hash_tree(:limit_depth => 1).should == {@a => {}}
+          expect(tag_class.hash_tree(:limit_depth => 1)).to eq({@a => {}})
         end
         it "limit_depth 2" do
-          tag_class.hash_tree(:limit_depth => 2).should == {@a => {@b => {}, @b2 => {}}}
+          expect(tag_class.hash_tree(:limit_depth => 2)).to eq({@a => {@b => {}, @b2 => {}}})
         end
         it "limit_depth 3" do
-          tag_class.hash_tree(:limit_depth => 3).should == {@a => {@b => {@c1 => {}, @c2 => {}}, @b2 => {}}}
+          expect(tag_class.hash_tree(:limit_depth => 3)).to eq({@a => {@b => {@c1 => {}, @c2 => {}}, @b2 => {}}})
         end
         it "limit_depth 4" do
-          tag_class.hash_tree(:limit_depth => 4).should == @full_tree
+          expect(tag_class.hash_tree(:limit_depth => 4)).to eq(@full_tree)
         end
         it "no limit holdum" do
-          tag_class.hash_tree.should == @full_tree
+          expect(tag_class.hash_tree).to eq(@full_tree)
         end
       end
 
@@ -500,7 +503,7 @@ shared_examples_for Tag do
         # the named scope is complicated enough that an incorrect join could result in unnecessarily
         # duplicated rows:
         a = scope.collect { |ea| ea.id }
-        a.should == a.uniq
+        expect(a).to eq(a.uniq)
       end
 
       context "#hash_tree_scope" do
@@ -529,25 +532,25 @@ shared_examples_for Tag do
         before :each do
         end
         it "returns {} for depth 0" do
-          @b.hash_tree(:limit_depth => 0).should == {}
+          expect(@b.hash_tree(:limit_depth => 0)).to eq({})
         end
         it "limit_depth 1" do
-          @b.hash_tree(:limit_depth => 1).should == {@b => {}}
+          expect(@b.hash_tree(:limit_depth => 1)).to eq({@b => {}})
         end
         it "limit_depth 2" do
-          @b.hash_tree(:limit_depth => 2).should == {@b => {@c1 => {}, @c2 => {}}}
+          expect(@b.hash_tree(:limit_depth => 2)).to eq({@b => {@c1 => {}, @c2 => {}}})
         end
         it "limit_depth 3" do
-          @b.hash_tree(:limit_depth => 3).should == {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}}
+          expect(@b.hash_tree(:limit_depth => 3)).to eq({@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}})
         end
         it "no limit holdum from subsubroot" do
-          @c1.hash_tree.should == {@c1 => {@d1 => {}}}
+          expect(@c1.hash_tree).to eq({@c1 => {@d1 => {}}})
         end
         it "no limit holdum from subroot" do
-          @b.hash_tree.should == {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}}
+          expect(@b.hash_tree).to eq({@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}})
         end
         it "no limit holdum from root" do
-          @a.hash_tree.should == @full_tree
+          expect(@a.hash_tree).to eq(@full_tree)
         end
       end
     end
@@ -556,13 +559,13 @@ shared_examples_for Tag do
       it 'should find_or_create very deep nodes' do
         expected_ancestry_path = (1..200).to_a.map { |ea| ea.to_s }
         target = tag_class.find_or_create_by_path(expected_ancestry_path)
-        target.ancestry_path.should == expected_ancestry_path
+        expect(target.ancestry_path).to eq(expected_ancestry_path)
       end
     end
 
     describe 'DOT rendering' do
       it 'should render for an empty scope' do
-        tag_class.to_dot_digraph(tag_class.where("0=1")).should == "digraph G {\n}\n"
+        expect(tag_class.to_dot_digraph(tag_class.where("0=1"))).to eq("digraph G {\n}\n")
       end
       it 'should render for an empty scope' do
         tag_class.find_or_create_by_path(%w(a b1 c1))
@@ -570,7 +573,7 @@ shared_examples_for Tag do
         tag_class.find_or_create_by_path(%w(a b2 c3))
         a, b1, b2, c1, c2, c3 = %w(a b1 b2 c1 c2 c3).map { |ea| tag_class.where(:name => ea).first.id }
         dot = tag_class.roots.first.to_dot_digraph
-        dot.should == <<-DOT
+        expect(dot).to eq <<-DOT
 digraph G {
   #{a} [label="a"]
   #{a} -> #{b1}