mongoid-tree 1.0.1 → 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 839d3ab28af5b3c0b2c9d4050f1c6940c444bd29
+  data.tar.gz: c9d5033394a48416907f5500fa990b8bf6d96f6e
+SHA512:
+  metadata.gz: a85f4ac7c49b858afd70a696aa0595df7af63ae85f21b15330cc3b88b3e277ee30cec3f1fe43dad34246126d3dec8f1da701a162430878f0ae30ef363e569696
+  data.tar.gz: 458d20a30a99b0940c882e14bc080b5c2efaeedbc90f92cc28eae56ee835795194f8695d3c9c9a55e5f0e6977a4ef7eec97d19860b845b9f3656b15d475848f1

data/Gemfile

@@ -1,6 +1,7 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
 
 gem 'guard-rspec', '>= 0.6.0'
 gem 'ruby_gntp',   '>= 0.3.4'
+gem 'rb-fsevent' if RUBY_PLATFORM =~ /darwin/

data/lib/mongoid/tree.rb

@@ -103,7 +103,7 @@ module Mongoid
     end
 
     ##
-    # This module implements class methods that will be available 
+    # This module implements class methods that will be available
     # on the document that includes Mongoid::Tree
     module ClassMethods
 
@@ -213,7 +213,7 @@ module Mongoid
     #   @note Generated by Mongoid
     #
     #   @param [Mongoid::Tree] document
-    
+
     ##
     # @!method parent_ids
     #   Returns a list of the document's parent_ids, starting with the root node.
@@ -272,7 +272,7 @@ module Mongoid
     #
     # @return [Mongoid::Criteria] Mongoid criteria to retrieve the documents ancestors
     def ancestors
-      base_class.where(:_id.in => parent_ids)
+      base_class.or(parent_ids.map { |id| { :_id => id } })
     end
 
     ##

data/lib/mongoid/tree/ordering.rb

@@ -37,7 +37,7 @@ module Mongoid
 
         default_scope asc(:position)
 
-        before_save :assign_default_position
+        before_save :assign_default_position, :if => :assign_default_position?
         before_save :reposition_former_siblings, :if => :sibling_reposition_required?
         after_destroy :move_lower_siblings_up
       end
@@ -45,29 +45,39 @@ module Mongoid
       ##
       # Returns a chainable criteria for this document's ancestors
       #
-      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the documents ancestors
+      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the document's ancestors
       def ancestors
-        base_class.unscoped.where(:_id.in => parent_ids)
+        base_class.unscoped { super }
       end
 
       ##
       # Returns siblings below the current document.
-      # Siblings with a position greater than this documents's position.
+      # Siblings with a position greater than this document's position.
       #
-      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the documents lower_siblings
+      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the document's lower siblings
       def lower_siblings
         self.siblings.where(:position.gt => self.position)
       end
 
       ##
       # Returns siblings above the current document.
-      # Siblings with a position lower than this documents's position.
+      # Siblings with a position lower than this document's position.
       #
-      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the documents higher_siblings
+      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the document's higher siblings
       def higher_siblings
         self.siblings.where(:position.lt => self.position)
       end
 
+      ##
+      # Returns siblings between the current document and the other document
+      # Siblings with a position between this document's position and the other document's position.
+      #
+      # @return [Mongoid::Criteria] Mongoid criteria to retrieve the documents between this and the other document
+      def siblings_between(other)
+        range = [self.position, other.position].sort
+        self.siblings.where(:position.gt => range.first, :position.lt => range.last)
+      end
+
       ##
       # Returns the lowest sibling (could be self)
       #
@@ -123,9 +133,7 @@ module Mongoid
       #
       # @return [undefined]
       def move_up
-        return if at_top?
-        siblings.where(:position => self.position - 1).first.inc(:position, 1)
-        inc(:position, -1)
+        switch_with_sibling_at_offset(-1) unless at_top?
       end
 
       ##
@@ -133,9 +141,7 @@ module Mongoid
       #
       # @return [undefined]
       def move_down
-        return if at_bottom?
-        siblings.where(:position => self.position + 1).first.inc(:position, -1)
-        inc(:position, 1)
+        switch_with_sibling_at_offset(1) unless at_bottom?
       end
 
       ##
@@ -147,23 +153,19 @@ module Mongoid
       #
       # @return [undefined]
       def move_above(other)
-        unless sibling_of?(other)
-          self.parent_id = other.parent_id
-          save!
-        end
+        ensure_to_be_sibling_of(other)
 
         if position > other.position
           new_position = other.position
-          other.lower_siblings.where(:position.lt => self.position).each { |s| s.inc(:position, 1) }
+          self.siblings_between(other).inc(:position, 1)
           other.inc(:position, 1)
-          self.position = new_position
-          save!
         else
           new_position = other.position - 1
-          other.higher_siblings.where(:position.gt => self.position).each { |s| s.inc(:position, -1) }
-          self.position = new_position
-          save!
+          self.siblings_between(other).inc(:position, -1)
         end
+
+        self.position = new_position
+        save!
       end
 
       ##
@@ -175,36 +177,43 @@ module Mongoid
       #
       # @return [undefined]
       def move_below(other)
-        unless sibling_of?(other)
-          self.parent_id = other.parent_id
-          save!
-        end
+        ensure_to_be_sibling_of(other)
 
         if position > other.position
           new_position = other.position + 1
-          other.lower_siblings.where(:position.lt => self.position).each { |s| s.inc(:position, 1) }
-          self.position = new_position
-          save!
+          self.siblings_between(other).inc(:position, 1)
         else
           new_position = other.position
-          other.higher_siblings.where(:position.gt => self.position).each { |s| s.inc(:position, -1) }
+          self.siblings_between(other).inc(:position, -1)
           other.inc(:position, -1)
-          self.position = new_position
-          save!
         end
+
+        self.position = new_position
+        save!
       end
 
     private
 
+      def switch_with_sibling_at_offset(offset)
+        siblings.where(:position => self.position + offset).first.inc(:position, -offset)
+        inc(:position, offset)
+      end
+
+      def ensure_to_be_sibling_of(other)
+        return if sibling_of?(other)
+        self.parent_id = other.parent_id
+        save!
+      end
+
       def move_lower_siblings_up
-        lower_siblings.each { |s| s.inc(:position, -1) }
+        lower_siblings.inc(:position, -1)
       end
 
       def reposition_former_siblings
         former_siblings = base_class.where(:parent_id => attribute_was('parent_id')).
                                      and(:position.gt => (attribute_was('position') || 0)).
                                      excludes(:id => self.id)
-        former_siblings.each { |s| s.inc(:position,  -1) }
+        former_siblings.inc(:position,  -1)
       end
 
       def sibling_reposition_required?
@@ -212,14 +221,16 @@ module Mongoid
       end
 
       def assign_default_position
-        return unless self.position.nil? || self.parent_id_changed?
-
-        if self.siblings.empty? || self.siblings.collect(&:position).compact.empty?
-          self.position = 0
+        self.position = if self.siblings.where(:position.ne => nil).any?
+          self.last_sibling_in_list.position + 1
         else
-          self.position = self.siblings.order_by(:position.desc).first.position.to_i + 1
+          0
         end
       end
+
+      def assign_default_position?
+        self.position.nil? || self.parent_id_changed?
+      end
     end
   end
 end

data/spec/mongoid/tree/ordering_spec.rb

@@ -6,9 +6,9 @@ describe Mongoid::Tree::Ordering do
 
   it "should store position as an Integer with a default of nil" do
     f = OrderedNode.fields['position']
-    f.should_not be_nil
-    f.options[:type].should == Integer
-    f.options[:default].should == nil
+    expect(f).not_to be_nil
+    expect(f.options[:type]).to eq(Integer)
+    expect(f.options[:default]).not_to be
   end
 
   describe 'when saved' do
@@ -25,48 +25,48 @@ describe Mongoid::Tree::Ordering do
     end
 
     it "should assign a default position of 0 to each node without a sibling" do
-      node(:child).position.should == 0
-      node(:subchild).position.should == 0
-      node(:subsubchild).position.should == 0
+      expect(node(:child).position).to eq(0)
+      expect(node(:subchild).position).to eq(0)
+      expect(node(:subsubchild).position).to eq(0)
     end
 
     it "should place siblings at the end of the list by default" do
-      node(:root).position.should == 0
-      node(:other_root).position.should == 1
-      node(:other_child).position.should == 0
-      node(:another_child).position.should == 1
+      expect(node(:root).position).to eq(0)
+      expect(node(:other_root).position).to eq(1)
+      expect(node(:other_child).position).to eq(0)
+      expect(node(:another_child).position).to eq(1)
     end
 
     it "should move a node to the end of a list when it is moved to a new parent" do
       other_root = node(:other_root)
       child = node(:child)
-      child.position.should == 0
+      expect(child.position).to eq(0)
       other_root.children << child
       child.reload
-      child.position.should == 2
+      expect(child.position).to eq(2)
     end
 
     it "should correctly reposition siblings when one of them is removed" do
       node(:other_child).destroy
-      node(:another_child).position.should == 0
+      expect(node(:another_child).position).to eq(0)
     end
 
     it "should correctly reposition siblings when one of them is added to another parent" do
       node(:root).children << node(:other_child)
-      node(:another_child).position.should == 0
+      expect(node(:another_child).position).to eq(0)
     end
 
     it "should correctly reposition siblings when the parent is changed" do
       other_child = node(:other_child)
       other_child.parent = node(:root)
       other_child.save!
-      node(:another_child).position.should == 0
+      expect(node(:another_child).position).to eq(0)
     end
 
     it "should not reposition siblings when it's not yet saved" do
       new_node = OrderedNode.new(:name => 'new')
       new_node.parent = node(:root)
-      new_node.should_not_receive(:reposition_former_siblings)
+      expect(new_node).not_to receive(:reposition_former_siblings)
       new_node.save
     end
   end
@@ -85,8 +85,8 @@ describe Mongoid::Tree::Ordering do
     describe ':move_children_to_parent' do
       it "should set its childen's parent_id to the documents parent_id" do
         node(:child).move_children_to_parent
-        node(:child).should be_leaf
-        node(:root).children.to_a.should == [node(:child), node(:other_child), node(:subchild)]
+        expect(node(:child)).to be_leaf
+        expect(node(:root).children.to_a).to eq([node(:child), node(:other_child), node(:subchild)])
       end
     end
   end
@@ -105,68 +105,68 @@ describe Mongoid::Tree::Ordering do
     describe '#lower_siblings' do
       it "should return a collection of siblings lower on the list" do
         node(:second_child_of_first_root).reload
-        node(:first_root).lower_siblings.to_a.should == [node(:second_root), node(:third_root)]
-        node(:second_root).lower_siblings.to_a.should == [node(:third_root)]
-        node(:third_root).lower_siblings.to_a.should == []
-        node(:first_child_of_first_root).lower_siblings.to_a.should == [node(:second_child_of_first_root)]
-        node(:second_child_of_first_root).lower_siblings.to_a.should == []
+        expect(node(:first_root).lower_siblings.to_a).to eq([node(:second_root), node(:third_root)])
+        expect(node(:second_root).lower_siblings.to_a).to eq([node(:third_root)])
+        expect(node(:third_root).lower_siblings.to_a).to eq([])
+        expect(node(:first_child_of_first_root).lower_siblings.to_a).to eq([node(:second_child_of_first_root)])
+        expect(node(:second_child_of_first_root).lower_siblings.to_a).to eq([])
       end
     end
 
     describe '#higher_siblings' do
       it "should return a collection of siblings lower on the list" do
-        node(:first_root).higher_siblings.to_a.should == []
-        node(:second_root).higher_siblings.to_a.should == [node(:first_root)]
-        node(:third_root).higher_siblings.to_a.should == [node(:first_root), node(:second_root)]
-        node(:first_child_of_first_root).higher_siblings.to_a.should == []
-        node(:second_child_of_first_root).higher_siblings.to_a.should == [node(:first_child_of_first_root)]
+        expect(node(:first_root).higher_siblings.to_a).to eq([])
+        expect(node(:second_root).higher_siblings.to_a).to eq([node(:first_root)])
+        expect(node(:third_root).higher_siblings.to_a).to eq([node(:first_root), node(:second_root)])
+        expect(node(:first_child_of_first_root).higher_siblings.to_a).to eq([])
+        expect(node(:second_child_of_first_root).higher_siblings.to_a).to eq([node(:first_child_of_first_root)])
       end
     end
 
     describe '#at_top?' do
       it "should return true when the node is first in the list" do
-        node(:first_root).should be_at_top
-        node(:first_child_of_first_root).should be_at_top
+        expect(node(:first_root)).to be_at_top
+        expect(node(:first_child_of_first_root)).to be_at_top
       end
 
       it "should return false when the node is not first in the list" do
-        node(:second_root).should_not be_at_top
-        node(:third_root).should_not be_at_top
-        node(:second_child_of_first_root).should_not be_at_top
+        expect(node(:second_root)).not_to be_at_top
+        expect(node(:third_root)).not_to be_at_top
+        expect(node(:second_child_of_first_root)).not_to be_at_top
       end
     end
 
     describe '#at_bottom?' do
       it "should return true when the node is last in the list" do
-        node(:third_root).should be_at_bottom
-        node(:second_child_of_first_root).should be_at_bottom
+        expect(node(:third_root)).to be_at_bottom
+        expect(node(:second_child_of_first_root)).to be_at_bottom
       end
 
       it "should return false when the node is not last in the list" do
-        node(:first_root).should_not be_at_bottom
-        node(:second_root).should_not be_at_bottom
-        node(:first_child_of_first_root).should_not be_at_bottom
+        expect(node(:first_root)).not_to be_at_bottom
+        expect(node(:second_root)).not_to be_at_bottom
+        expect(node(:first_child_of_first_root)).not_to be_at_bottom
       end
     end
 
     describe '#last_sibling_in_list' do
       it "should return the last sibling in the list containing the current sibling" do
-        node(:first_root).last_sibling_in_list.should == node(:third_root)
-        node(:second_root).last_sibling_in_list.should == node(:third_root)
-        node(:third_root).last_sibling_in_list.should == node(:third_root)
+        expect(node(:first_root).last_sibling_in_list).to eq(node(:third_root))
+        expect(node(:second_root).last_sibling_in_list).to eq(node(:third_root))
+        expect(node(:third_root).last_sibling_in_list).to eq(node(:third_root))
       end
     end
 
     describe '#first_sibling_in_list' do
       it "should return the first sibling in the list containing the current sibling" do
-        node(:first_root).first_sibling_in_list.should == node(:first_root)
-        node(:second_root).first_sibling_in_list.should == node(:first_root)
-        node(:third_root).first_sibling_in_list.should == node(:first_root)
+        expect(node(:first_root).first_sibling_in_list).to eq(node(:first_root))
+        expect(node(:second_root).first_sibling_in_list).to eq(node(:first_root))
+        expect(node(:third_root).first_sibling_in_list).to eq(node(:first_root))
       end
     end
 
-    describe 'ancestors' do
-      it "#ancestors should be returned in the correct order" do
+    describe '#ancestors' do
+      it "should be returned in the correct order" do
         setup_tree <<-ENDTREE
           - root:
             - level_1_a
@@ -175,7 +175,21 @@ describe Mongoid::Tree::Ordering do
                 - leaf
         ENDTREE
 
-        node(:leaf).ancestors.to_a.should == [node(:root), node(:level_1_b), node(:level_2_a)]
+        expect(node(:leaf).ancestors.to_a).to eq([node(:root), node(:level_1_b), node(:level_2_a)])
+      end
+
+      it "should return the ancestors in correct order even after rearranging" do
+        setup_tree <<-ENDTREE
+          - root:
+            - child:
+              - subchild
+        ENDTREE
+
+        child = node(:child); child.parent = nil; child.save!
+        root = node(:root); root.parent = node(:child); root.save!
+        subchild = node(:subchild); subchild.parent = root; subchild.save!
+
+        expect(subchild.ancestors.to_a).to eq([child, root])
       end
     end
   end
@@ -199,7 +213,7 @@ describe Mongoid::Tree::Ordering do
       it 'should fix positions within the current list when moving an sibling away from its current parent' do
         node_to_move = node(:first_child_of_first_root)
         node_to_move.move_below(node(:first_child_of_second_root))
-        node(:second_child_of_first_root).position.should == 0
+        expect(node(:second_child_of_first_root).position).to eq(0)
       end
 
       it 'should work when moving to a different parent' do
@@ -207,8 +221,8 @@ describe Mongoid::Tree::Ordering do
         new_parent = node(:second_root)
         node_to_move.move_below(node(:first_child_of_second_root))
         node_to_move.reload
-        node_to_move.should be_at_bottom
-        node(:first_child_of_second_root).should be_at_top
+        expect(node_to_move).to be_at_bottom
+        expect(node(:first_child_of_second_root)).to be_at_top
       end
 
       it 'should be able to move the first node below the second node' do
@@ -217,8 +231,8 @@ describe Mongoid::Tree::Ordering do
         first_node.move_below(second_node)
         first_node.reload
         second_node.reload
-        second_node.should be_at_top
-        first_node.higher_siblings.to_a.should == [second_node]
+        expect(second_node).to be_at_top
+        expect(first_node.higher_siblings.to_a).to eq([second_node])
       end
 
       it 'should be able to move the last node below the first node' do
@@ -227,9 +241,9 @@ describe Mongoid::Tree::Ordering do
         last_node.move_below(first_node)
         first_node.reload
         last_node.reload
-        last_node.should_not be_at_bottom
-        node(:second_root).should be_at_bottom
-        last_node.higher_siblings.to_a.should == [first_node]
+        expect(last_node).not_to be_at_bottom
+        expect(node(:second_root)).to be_at_bottom
+        expect(last_node.higher_siblings.to_a).to eq([first_node])
       end
     end
 
@@ -237,7 +251,7 @@ describe Mongoid::Tree::Ordering do
       it 'should fix positions within the current list when moving an sibling away from its current parent' do
         node_to_move = node(:first_child_of_first_root)
         node_to_move.move_above(node(:first_child_of_second_root))
-        node(:second_child_of_first_root).position.should == 0
+        expect(node(:second_child_of_first_root).position).to eq(0)
       end
 
       it 'should work when moving to a different parent' do
@@ -245,8 +259,8 @@ describe Mongoid::Tree::Ordering do
         new_parent = node(:second_root)
         node_to_move.move_above(node(:first_child_of_second_root))
         node_to_move.reload
-        node_to_move.should be_at_top
-        node(:first_child_of_second_root).should be_at_bottom
+        expect(node_to_move).to be_at_top
+        expect(node(:first_child_of_second_root)).to be_at_bottom
       end
 
       it 'should be able to move the last node above the second node' do
@@ -255,8 +269,8 @@ describe Mongoid::Tree::Ordering do
         last_node.move_above(second_node)
         last_node.reload
         second_node.reload
-        second_node.should be_at_bottom
-        last_node.higher_siblings.to_a.should == [node(:first_root)]
+        expect(second_node).to be_at_bottom
+        expect(last_node.higher_siblings.to_a).to eq([node(:first_root)])
       end
 
       it 'should be able to move the first node above the last node' do
@@ -265,15 +279,15 @@ describe Mongoid::Tree::Ordering do
         first_node.move_above(last_node)
         first_node.reload
         last_node.reload
-        node(:second_root).should be_at_top
-        first_node.higher_siblings.to_a.should == [node(:second_root)]
+        expect(node(:second_root)).to be_at_top
+        expect(first_node.higher_siblings.to_a).to eq([node(:second_root)])
       end
     end
 
     describe "#move_to_top" do
       it "should return true when attempting to move the first sibling" do
-        node(:first_root).move_to_top.should == true
-        node(:first_child_of_first_root).move_to_top.should == true
+        expect(node(:first_root).move_to_top).to eq(true)
+        expect(node(:first_child_of_first_root).move_to_top).to eq(true)
       end
 
       it "should be able to move the last sibling to the top" do
@@ -281,17 +295,17 @@ describe Mongoid::Tree::Ordering do
         last_node = node(:third_root)
         last_node.move_to_top
         first_node.reload
-        last_node.should be_at_top
-        first_node.should_not be_at_top
-        first_node.higher_siblings.to_a.should == [last_node]
-        last_node.lower_siblings.to_a.should == [first_node, node(:second_root)]
+        expect(last_node).to be_at_top
+        expect(first_node).not_to be_at_top
+        expect(first_node.higher_siblings.to_a).to eq([last_node])
+        expect(last_node.lower_siblings.to_a).to eq([first_node, node(:second_root)])
       end
     end
 
     describe "#move_to_bottom" do
       it "should return true when attempting to move the last sibling" do
-        node(:third_root).move_to_bottom.should == true
-        node(:second_child_of_first_root).move_to_bottom.should == true
+        expect(node(:third_root).move_to_bottom).to eq(true)
+        expect(node(:second_child_of_first_root).move_to_bottom).to eq(true)
       end
 
       it "should be able to move the first sibling to the bottom" do
@@ -301,27 +315,27 @@ describe Mongoid::Tree::Ordering do
         first_node.move_to_bottom
         middle_node.reload
         last_node.reload
-        first_node.should_not be_at_top
-        first_node.should be_at_bottom
-        last_node.should_not be_at_bottom
-        last_node.should_not be_at_top
-        middle_node.should be_at_top
-        first_node.lower_siblings.to_a.should == []
-        last_node.higher_siblings.to_a.should == [middle_node]
+        expect(first_node).not_to be_at_top
+        expect(first_node).to be_at_bottom
+        expect(last_node).not_to be_at_bottom
+        expect(last_node).not_to be_at_top
+        expect(middle_node).to be_at_top
+        expect(first_node.lower_siblings.to_a).to eq([])
+        expect(last_node.higher_siblings.to_a).to eq([middle_node])
       end
     end
 
     describe "#move_up" do
       it "should correctly move nodes up" do
         node(:third).move_up
-        node(:third_root).children.should == [node(:first), node(:third), node(:second)]
+        expect(node(:third_root).children).to eq([node(:first), node(:third), node(:second)])
       end
     end
 
     describe "#move_down" do
       it "should correctly move nodes down" do
         node(:first).move_down
-        node(:third_root).children.should == [node(:second), node(:first), node(:third)]
+        expect(node(:third_root).children).to eq([node(:second), node(:first), node(:third)])
       end
     end
   end # moving nodes around

data/spec/mongoid/tree/traversal_spec.rb

@@ -19,7 +19,7 @@ describe Mongoid::Tree::Traversal do
     end
 
     it "should default to depth_first traversal" do
-      subject.should_receive(:depth_first_traversal)
+      expect(subject).to receive(:depth_first_traversal)
       subject.traverse {}
     end
   end
@@ -42,12 +42,12 @@ describe Mongoid::Tree::Traversal do
       it "should traverse correctly" do
         result = []
         node(:node1).traverse(:depth_first) { |node| result << node }
-        result.collect { |n| n.name.to_sym }.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+        expect(result.collect { |n| n.name.to_sym }).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
       end
 
       it "should return and array containing the results of the block for each node" do
         result = node(:node1).traverse(:depth_first) { |n| n.name.to_sym }
-        result.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+        expect(result).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
       end
     end
 
@@ -69,7 +69,7 @@ describe Mongoid::Tree::Traversal do
 
       it "should traverse correctly" do
         result = node(:node1).traverse(:depth_first) { |n| n.name.to_sym }
-        result.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+        expect(result).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
       end
     end
 
@@ -92,12 +92,12 @@ describe Mongoid::Tree::Traversal do
       it 'should iterate through the nodes in the correct order' do
         result = []
         node(:node1).traverse(:depth_first) { |node| result << node }
-        result.collect { |n| n.name.to_sym }.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+        expect(result.collect { |n| n.name.to_sym }).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
       end
 
       it 'should return the nodes in the correct order' do
         result = node(:node1).traverse(:depth_first)
-        result.collect { |n| n.name.to_sym }.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+        expect(result.collect { |n| n.name.to_sym }).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
       end
 
     end
@@ -121,12 +121,12 @@ describe Mongoid::Tree::Traversal do
     it "should traverse correctly" do
       result = []
       node(:node1).traverse(:breadth_first) { |n| result << n }
-      result.collect { |n| n.name.to_sym }.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+      expect(result.collect { |n| n.name.to_sym }).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
     end
 
     it "should return and array containing the results of the block for each node" do
       result = node(:node1).traverse(:breadth_first) { |n| n.name.to_sym }
-      result.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
+      expect(result).to eq([:node1, :node2, :node3, :node4, :node5, :node6, :node7])
     end
 
   end
@@ -144,31 +144,31 @@ describe Mongoid::Tree::Traversal do
       Node.stub(:roots).and_return [@root1, @root2]
     end
 
-    it 'grabs each root' do
-      Node.should_receive(:roots).and_return []
+    it 'should grab each root' do
+      expect(Node).to receive(:roots).and_return []
 
-      Node.traverse.should == []
+      expect(Node.traverse).to eq([])
     end
 
-    it 'defaults the "type" arg to :depth_first' do
-      @root1.should_receive(:traverse).with(:depth_first).and_return([])
-      @root2.should_receive(:traverse).with(:depth_first).and_return([])
+    it 'should default the "type" arg to :depth_first' do
+      expect(@root1).to receive(:traverse).with(:depth_first).and_return([])
+      expect(@root2).to receive(:traverse).with(:depth_first).and_return([])
 
-      Node.traverse.should == []
+      expect(Node.traverse).to eq([])
     end
 
-    it 'traverses each root' do
-      @root1.should_receive(:traverse).and_return([1, 2])
-      @root2.should_receive(:traverse).and_return([3, 4])
+    it 'should traverse each root' do
+      expect(@root1).to receive(:traverse).and_return([1, 2])
+      expect(@root2).to receive(:traverse).and_return([3, 4])
 
-      Node.traverse.should == [1, 2, 3, 4]
+      expect(Node.traverse).to eq([1, 2, 3, 4])
     end
 
     describe 'when the "type" arg is :breadth_first' do
 
-      it 'traverses breadth-first' do
-        @root1.should_receive(:traverse).with(:breadth_first).and_return([])
-        @root2.should_receive(:traverse).with(:breadth_first).and_return([])
+      it 'should traverse breadth-first' do
+        expect(@root1).to receive(:traverse).with(:breadth_first).and_return([])
+        expect(@root2).to receive(:traverse).with(:breadth_first).and_return([])
 
         Node.traverse :breadth_first
       end

data/spec/mongoid/tree_spec.rb

@@ -6,46 +6,46 @@ describe Mongoid::Tree do
 
   it "should reference many children as inverse of parent with index" do
     a = Node.reflect_on_association(:children)
-    a.should be
-    a.macro.should eql(:has_many)
-    a.class_name.should eql('Node')
-    a.foreign_key.should eql('parent_id')
-    Node.index_options.should have_key(:parent_id => 1)
+    expect(a).to be
+    expect(a.macro).to eq(:has_many)
+    expect(a.class_name).to eq('Node')
+    expect(a.foreign_key).to eq('parent_id')
+    expect(Node.index_options).to have_key(:parent_id => 1)
   end
 
   it "should be referenced in one parent as inverse of children" do
     a = Node.reflect_on_association(:parent)
-    a.should be
-    a.macro.should eql(:belongs_to)
-    a.class_name.should eql('Node')
-    a.inverse_of.should eql(:children)
+    expect(a).to be
+    expect(a.macro).to eq(:belongs_to)
+    expect(a.class_name).to eq('Node')
+    expect(a.inverse_of).to eq(:children)
   end
 
   it "should store parent_ids as Array with [] as default with index" do
     f = Node.fields['parent_ids']
-    f.should be
-    f.options[:type].should eql(Array)
-    f.options[:default].should eql([])
-    Node.index_options.should have_key(:parent_ids => 1)
+    expect(f).to be
+    expect(f.options[:type]).to eq(Array)
+    expect(f.options[:default]).to eq([])
+    expect(Node.index_options).to have_key(:parent_ids => 1)
   end
 
   describe 'when new' do
     it "should not require a saved parent when adding children" do
       root = Node.new(:name => 'root'); child = Node.new(:name => 'child')
-      expect { root.children << child; root.save! }.to_not raise_error(Mongoid::Errors::DocumentNotFound)
-      child.should be_persisted
+      expect { root.children << child; root.save! }.to_not raise_error
+      expect(child).to be_persisted
     end
 
     it "should not be saved when parent is not saved" do
       root = Node.new(:name => 'root'); child = Node.new(:name => 'child')
-      child.should_not_receive(:save)
+      expect(child).not_to receive(:save)
       root.children << child
     end
 
     it "should save its unsaved children" do
       root = Node.new(:name => 'root'); child = Node.new(:name => 'child')
       root.children << child
-      child.should_receive(:save)
+      expect(child).to receive(:save)
       root.save
     end
   end
@@ -66,61 +66,61 @@ describe Mongoid::Tree do
     it "should set the child's parent_id when added to parent's children" do
       root = Node.create; child = Node.create
       root.children << child
-      child.parent.should eq(root)
-      child.parent_id.should eq(root.id)
+      expect(child.parent).to eq(root)
+      expect(child.parent_id).to eq(root.id)
     end
 
     it "should set the child's parent_id parent is set on child" do
       root = Node.create; child = Node.create
       child.parent = root
-      child.parent.should eq(root)
-      child.parent_id.should eq(root.id)
+      expect(child.parent).to eq(root)
+      expect(child.parent_id).to eq(root.id)
     end
 
     it "should rebuild its parent_ids" do
       root = Node.create; child = Node.create
       root.children << child
-      child.parent_ids.should == [root.id]
+      expect(child.parent_ids).to eq([root.id])
     end
 
     it "should rebuild its children's parent_ids when its own parent_ids changed" do
       other_root = node(:other_root); child = node(:child); subchild = node(:subchild);
       other_root.children << child
       subchild.reload # To get the updated version
-      subchild.parent_ids.should == [other_root.id, child.id]
+      expect(subchild.parent_ids).to eq([other_root.id, child.id])
     end
 
     it "should correctly rebuild its descendants' parent_ids when moved into an other subtree" do
       subchild = node(:subchild); subsubchild = node(:subsubchild); other_child = node(:other_child)
       other_child.children << subchild
       subsubchild.reload
-      subsubchild.parent_ids.should == [node(:other_root).id, other_child.id, subchild.id]
+      expect(subsubchild.parent_ids).to eq([node(:other_root).id, other_child.id, subchild.id])
     end
 
     it "should rebuild its children's parent_ids when its own parent_id is removed" do
       c = node(:child)
       c.parent_id = nil
       c.save
-      node(:subchild).parent_ids.should == [node(:child).id]
+      expect(node(:subchild).parent_ids).to eq([node(:child).id])
     end
 
     it "should not rebuild its children's parent_ids when it's not required" do
       root = node(:root)
-      root.should_not_receive(:rearrange_children)
+      expect(root).not_to receive(:rearrange_children)
       root.save
     end
 
     it "should prevent cycles" do
       child = node(:child)
       child.parent = node(:subchild)
-      child.should_not be_valid
-      child.errors[:parent_id].should_not be_nil
+      expect(child).not_to be_valid
+      expect(child.errors[:parent_id]).not_to be_nil
     end
 
     it "should save its children when added" do
       new_child = Node.new(:name => 'new_child')
       node(:root).children << new_child
-      new_child.should be_persisted
+      expect(new_child).to be_persisted
     end
   end
 
@@ -139,7 +139,7 @@ describe Mongoid::Tree do
     it "should allow to store any subclass within the tree" do
       subclassed = SubclassedNode.create!(:name => 'subclassed_subchild')
       node(:child).children << subclassed
-      subclassed.root.should == node(:root)
+      expect(subclassed.root).to eq(node(:root))
     end
 
   end
@@ -159,23 +159,23 @@ describe Mongoid::Tree do
     describe ':nullify_children' do
       it "should set its children's parent_id to null" do
         node(:root).nullify_children
-        node(:child).should be_root
-        node(:subchild).reload.should_not be_descendant_of node(:root)
+        expect(node(:child)).to be_root
+        expect(node(:subchild).reload).not_to be_descendant_of node(:root)
       end
     end
 
     describe ':move_children_to_parent' do
       it "should set its childen's parent_id to the documents parent_id" do
         node(:child).move_children_to_parent
-        node(:child).should be_leaf
-        node(:root).children.to_a.should =~ [node(:child), node(:other_child), node(:subchild)]
+        expect(node(:child)).to be_leaf
+        expect(node(:root).children.to_a).to match_array([node(:child), node(:other_child), node(:subchild)])
       end
     end
 
     describe ':destroy_children' do
       it "should destroy all children" do
         root = node(:root)
-        root.children.should_receive(:destroy_all)
+        expect(root.children).to receive(:destroy_all)
         root.destroy_children
       end
     end
@@ -183,7 +183,7 @@ describe Mongoid::Tree do
     describe ':delete_descendants' do
       it "should delete all descendants" do
         root = node(:root)
-        Node.should_receive(:delete_all).with(:conditions => { :parent_ids => root.id })
+        expect(Node).to receive(:delete_all).with(:conditions => { :parent_ids => root.id })
         root.delete_descendants
       end
     end
@@ -204,137 +204,163 @@ describe Mongoid::Tree do
 
     describe '.root' do
       it "should return the first root document" do
-        Node.root.should == node(:root)
+        expect(Node.root).to eq(node(:root))
       end
     end
 
     describe '.roots' do
       it "should return all root documents" do
-        Node.roots.to_a.should == [node(:root), node(:other_root)]
+        expect(Node.roots.to_a).to eq([node(:root), node(:other_root)])
       end
     end
 
     describe '.leaves' do
       it "should return all leaf documents" do
-        Node.leaves.to_a.should =~ [node(:subchild), node(:other_child), node(:other_root)]
+        expect(Node.leaves.to_a).to match_array([node(:subchild), node(:other_child), node(:other_root)])
       end
     end
 
     describe '#root?' do
       it "should return true for root documents" do
-        node(:root).should be_root
+        expect(node(:root)).to be_root
       end
 
       it "should return false for non-root documents" do
-        node(:child).should_not be_root
+        expect(node(:child)).not_to be_root
       end
     end
 
     describe '#leaf?' do
       it "should return true for leaf documents" do
-        node(:subchild).should be_leaf
-        node(:other_child).should be_leaf
-        Node.new.should be_leaf
+        expect(node(:subchild)).to be_leaf
+        expect(node(:other_child)).to be_leaf
+        expect(Node.new).to be_leaf
       end
 
       it "should return false for non-leaf documents" do
-        node(:child).should_not be_leaf
-        node(:root).should_not be_leaf
+        expect(node(:child)).not_to be_leaf
+        expect(node(:root)).not_to be_leaf
       end
     end
 
     describe '#depth' do
       it "should return the depth of this document" do
-        node(:root).depth.should eq(0)
-        node(:child).depth.should eq(1)
-        node(:subchild).depth.should eq(2)
+        expect(node(:root).depth).to eq(0)
+        expect(node(:child).depth).to eq(1)
+        expect(node(:subchild).depth).to eq(2)
       end
     end
 
     describe '#root' do
       it "should return the root for this document" do
-        node(:subchild).root.should == node(:root)
+        expect(node(:subchild).root).to eq(node(:root))
       end
 
       it "should return itself when there is no root" do
         new_node = Node.new
-        new_node.root.should be(new_node)
+        expect(new_node.root).to be(new_node)
       end
 
       it "should return it root when it's not saved yet" do
         root = Node.new(:name => 'root')
         new_node = Node.new(:name => 'child')
         new_node.parent = root
-        new_node.root.should be(root)
+        expect(new_node.root).to be(root)
       end
     end
 
     describe 'ancestors' do
-      it "#ancestors should return the documents ancestors" do
-        node(:subchild).ancestors.to_a.should == [node(:root), node(:child)]
+      describe '#ancestors' do
+        it "should return the documents ancestors" do
+          expect(node(:subchild).ancestors.to_a).to eq([node(:root), node(:child)])
+        end
+
+        it "should return the ancestors in correct order even after rearranging" do
+          setup_tree <<-ENDTREE
+            - root:
+              - child:
+                - subchild
+          ENDTREE
+
+          child = node(:child); child.parent = nil; child.save!
+          root = node(:root); root.parent = node(:child); root.save!
+          subchild = node(:subchild); subchild.parent = root; subchild.save!
+
+          expect(subchild.ancestors.to_a).to eq([child, root])
+        end
       end
 
-      it "#ancestors_and_self should return the documents ancestors and itself" do
-        node(:subchild).ancestors_and_self.to_a.should == [node(:root), node(:child), node(:subchild)]
+      describe '#ancestors_and_self' do
+        it "should return the documents ancestors and itself" do
+          expect(node(:subchild).ancestors_and_self.to_a).to eq([node(:root), node(:child), node(:subchild)])
+        end
       end
 
       describe '#ancestor_of?' do
         it "should return true for ancestors" do
-          node(:child).should be_ancestor_of(node(:subchild))
+          expect(node(:child)).to be_ancestor_of(node(:subchild))
         end
 
         it "should return false for non-ancestors" do
-          node(:other_child).should_not be_ancestor_of(node(:subchild))
+          expect(node(:other_child)).not_to be_ancestor_of(node(:subchild))
         end
       end
     end
 
     describe 'descendants' do
-      it "#descendants should return the documents descendants" do
-        node(:root).descendants.to_a.should =~ [node(:child), node(:other_child), node(:subchild)]
+      describe '#descendants' do
+        it "should return the documents descendants" do
+          expect(node(:root).descendants.to_a).to match_array([node(:child), node(:other_child), node(:subchild)])
+        end
       end
 
-      it "#descendants_and_self should return the documents descendants and itself" do
-        node(:root).descendants_and_self.to_a.should =~ [node(:root), node(:child), node(:other_child), node(:subchild)]
+      describe '#descendants_and_self' do
+        it "should return the documents descendants and itself" do
+          expect(node(:root).descendants_and_self.to_a).to match_array([node(:root), node(:child), node(:other_child), node(:subchild)])
+        end
       end
 
       describe '#descendant_of?' do
         it "should return true for descendants" do
           subchild = node(:subchild)
-          subchild.should be_descendant_of(node(:child))
-          subchild.should be_descendant_of(node(:root))
+          expect(subchild).to be_descendant_of(node(:child))
+          expect(subchild).to be_descendant_of(node(:root))
         end
 
         it "should return false for non-descendants" do
-          node(:subchild).should_not be_descendant_of(node(:other_child))
+          expect(node(:subchild)).not_to be_descendant_of(node(:other_child))
         end
       end
     end
 
     describe 'siblings' do
-      it "#siblings should return the documents siblings" do
-        node(:child).siblings.to_a.should == [node(:other_child)]
+      describe '#siblings' do
+        it "should return the documents siblings" do
+          expect(node(:child).siblings.to_a).to eq([node(:other_child)])
+        end
       end
 
-      it "#siblings_and_self should return the documents siblings and itself" do
-        node(:child).siblings_and_self.should be_kind_of(Mongoid::Criteria)
-        node(:child).siblings_and_self.to_a.should == [node(:child), node(:other_child)]
+      describe '#siblings_and_self' do
+        it "should return the documents siblings and itself" do
+          expect(node(:child).siblings_and_self).to be_kind_of(Mongoid::Criteria)
+          expect(node(:child).siblings_and_self.to_a).to eq([node(:child), node(:other_child)])
+        end
       end
 
       describe '#sibling_of?' do
         it "should return true for siblings" do
-          node(:child).should be_sibling_of(node(:other_child))
+          expect(node(:child)).to be_sibling_of(node(:other_child))
         end
 
         it "should return false for non-siblings" do
-          node(:root).should_not be_sibling_of(node(:other_child))
+          expect(node(:root)).not_to be_sibling_of(node(:other_child))
         end
       end
     end
 
     describe '#leaves' do
       it "should return this documents leaves" do
-        node(:root).leaves.to_a.should =~ [node(:other_child), node(:subchild)]
+        expect(node(:root).leaves.to_a).to match_array([node(:other_child), node(:subchild)])
       end
     end
 
@@ -347,11 +373,11 @@ describe Mongoid::Tree do
     end
 
     it "should provide a before_rearrange callback" do
-      Node.should respond_to :before_rearrange
+      expect(Node).to respond_to :before_rearrange
     end
 
     it "should provida an after_rearrange callback" do
-      Node.should respond_to :after_rearrange
+      expect(Node).to respond_to :after_rearrange
     end
 
     describe 'before rearrange callback' do
@@ -359,8 +385,8 @@ describe Mongoid::Tree do
       it "should be called before the document is rearranged" do
         Node.before_rearrange :callback
         node = Node.new
-        node.should_receive(:callback).ordered
-        node.should_receive(:rearrange).ordered
+        expect(node).to receive(:callback).ordered
+        expect(node).to receive(:rearrange).ordered
         node.save
       end
 
@@ -371,8 +397,8 @@ describe Mongoid::Tree do
       it "should be called after the document is rearranged" do
         Node.after_rearrange :callback
         node = Node.new
-        node.should_receive(:rearrange).ordered
-        node.should_receive(:callback).ordered
+        expect(node).to receive(:rearrange).ordered
+        expect(node).to receive(:callback).ordered
         node.save
       end
 
@@ -383,7 +409,7 @@ describe Mongoid::Tree do
       it 'should not raise a NoMethodError' do
         node = NodeWithEmbeddedDocument.new
         document = node.build_embedded_document
-        expect { node.save }.to_not raise_error NoMethodError
+        expect { node.save }.to_not raise_error
       end
 
     end

data/spec/spec_helper.rb

@@ -13,6 +13,9 @@ end
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
   config.mock_with :rspec
   config.after(:each) { Mongoid.purge! }
 end

metadata

@@ -1,74 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-tree
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.0.2
 platform: ruby
 authors:
 - Benedikt Deicke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-12 00:00:00.000000000 Z
+date: 2013-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - <=
       - !ruby/object:Gem::Version
         version: '4.0'
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - <=
       - !ruby/object:Gem::Version
         version: '4.0'
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.9.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -76,7 +68,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -104,27 +95,26 @@ files:
 - .rspec
 homepage: https://github.com/benedikt/mongoid-tree
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A tree structure for Mongoid documents
 test_files: []
 has_rdoc: