mongoid-tree 0.3.1 → 0.4.0

data/Gemfile.lock

@@ -1,20 +1,20 @@
 PATH
   remote: .
   specs:
-    mongoid-tree (0.3.1)
-      mongoid (>= 2.0.0.beta.17)
+    mongoid-tree (0.4.0)
+      mongoid (>= 2.0.0.beta.20)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.0.0)
-      activesupport (= 3.0.0)
+    activemodel (3.0.1)
+      activesupport (= 3.0.1)
       builder (~> 2.1.2)
       i18n (~> 0.4.1)
-    activesupport (3.0.0)
-    autotest (4.4.1)
-    bson (1.1)
-    bson_ext (1.1)
+    activesupport (3.0.1)
+    autotest (4.4.2)
+    bson (1.1.1)
+    bson_ext (1.1.1)
     builder (2.1.2)
     diff-lcs (1.1.2)
     haml (2.2.24)
@@ -22,26 +22,26 @@ GEM
       haml (~> 2.2.8)
       rake (~> 0.8.2)
       rdoc (~> 2.3.0)
-    i18n (0.4.1)
-    mongo (1.0.9)
-      bson (>= 1.0.5)
-    mongoid (2.0.0.beta.19)
+    i18n (0.4.2)
+    mongo (1.1.1)
+      bson (>= 1.1.1)
+    mongoid (2.0.0.beta.20)
       activemodel (~> 3.0)
-      mongo (= 1.0.9)
+      mongo (~> 1.1)
       tzinfo (~> 0.3.22)
       will_paginate (~> 3.0.pre)
     rake (0.8.7)
     rdoc (2.3.0)
-    rspec (2.0.0.rc)
-      rspec-core (= 2.0.0.rc)
-      rspec-expectations (= 2.0.0.rc)
-      rspec-mocks (= 2.0.0.rc)
-    rspec-core (2.0.0.rc)
-    rspec-expectations (2.0.0.rc)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
       diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.0.rc)
-      rspec-core (= 2.0.0.rc)
-      rspec-expectations (= 2.0.0.rc)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
     tzinfo (0.3.23)
     will_paginate (3.0.pre2)
 
@@ -52,6 +52,6 @@ DEPENDENCIES
   autotest (>= 4.3.2)
   bson_ext (>= 1.0.4)
   hanna (>= 0.1.12)
-  mongoid (>= 2.0.0.beta.17)
+  mongoid (>= 2.0.0.beta.20)
   mongoid-tree!
-  rspec (>= 2.0.0.beta.18)
+  rspec (~> 2.0)

data/README.rdoc

@@ -2,9 +2,11 @@
 
 A tree structure for Mongoid documents using the materialized path pattern
 
+
 == Requirements
 
-* mongoid (>= 2.0.0.beta.17)
+* mongoid (>= 2.0.0.beta.20)
+
 
 == Install
 
@@ -20,17 +22,17 @@ You might want to remove the <tt>:require => 'mongoid/tree'</tt> option and expl
 
   bundle install
 
+
 == Usage
 
 Read the API documentation at http://benedikt.github.com/mongoid-tree and take a look at the Mongoid::Tree module
 
-  require 'mongoid/tree'
-
   class Node
     include Mongoid::Document
     include Mongoid::Tree
   end
 
+
 === Utility methods
 
 There are several utility methods that help getting to other related documents in the tree:
@@ -50,24 +52,64 @@ There are several utility methods that help getting to other related documents i
   node.siblings_and_self
   node.leaves
 
-In addition it's possible to check certain aspects of the documents position in the tree:
+In addition it's possible to check certain aspects of the document's position in the tree:
 
   node.root?
   node.leaf?
   node.depth
   node.ancestor_of?(other)
   node.descendant_of?(other)
+  node.sibling_of?(other)
 
 See Mongoid::Tree for more information on these methods.
 
+
+=== Ordering
+
+Mongoid::Tree doesn't order children by default. To enable ordering of tree nodes include the Mongoid::Tree::Ordering module. This will add a <tt>position</tt> field to your document and provide additional utility methods:
+
+  node.lower_siblings
+  node.higher_siblings
+  node.first_sibling_in_list
+  node.last_sibling_in_list
+
+  node.move_up
+  node.move_down
+  node.move_to_top
+  node.move_to_bottom
+  node.move_above(other)
+  node.move_below(other)
+
+  node.at_top?
+  node.at_bottom?
+
+Example:
+
+  class Node
+    include Mongoid::Document
+    include Mongoid::Tree
+    include Mongoid::Tree::Ordering
+  end
+
+See Mongoid::Tree::Ordering for more information on these methods.
+
 === Traversal
 
-It's possible to traverse the tree using different traversal methods. See Mongoid::Tree::Traversal for details
+It's possible to traverse the tree using different traversal methods using the Mongoid::Tree::Traversal module.
+
+Example:
+
+  class Node
+    include Mongoid::Document
+    include Mongoid::Tree
+    include Mongoid::Tree::Traversal
+  end
 
   node.traverse(:breadth_first) do |n|
     # Do something with Node n
   end
 
+
 === Destroying
 
 Mongoid::Tree does not handle destroying of nodes by default. However it provides several strategies that help you to deal with children of deleted documents. You can simply add them as <tt>before_destroy</tt> callbacks.
@@ -88,6 +130,7 @@ Example:
     before_destroy :nullify_children
   end
 
+
 === Callbacks
 
 There are two callbacks that are called before and after the rearranging process. This enables you to do additional computations after the documents position in the tree is updated. See Mongoid::Tree for details.
@@ -110,14 +153,17 @@ Example:
     end
   end
 
+
 == Known issues
 
 See http://github.com/benedikt/mongoid-tree/issues
 
+
 == Repository
 
 See http://github.com/benedikt/mongoid-tree and feel free to fork it!
 
+
 == Copyright
 
 Copyright (c) 2010 Benedikt Deicke. See LICENSE for details.

data/lib/mongoid/tree.rb

@@ -1,5 +1,3 @@
-require 'mongoid/tree/traversal'
-
 module Mongoid # :nodoc:
   ##
   # = Mongoid::Tree
@@ -81,10 +79,16 @@ module Mongoid # :nodoc:
   module Tree
     extend ActiveSupport::Concern
 
-    include Traversal
+    autoload :Ordering, 'mongoid/tree/ordering'
+    autoload :Traversal, 'mongoid/tree/traversal'
 
     included do
-      references_many :children, :class_name => self.name, :foreign_key => :parent_id, :inverse_of => :parent
+      references_many :children, :class_name => self.name, :foreign_key => :parent_id, :inverse_of => :parent do
+        def <<(*objects)
+          super; objects.each { |c| c.parent = @parent }
+        end
+      end
+
       referenced_in :parent, :class_name => self.name, :inverse_of => :children, :index => true
 
       field :parent_ids, :type => Array, :default => []
@@ -228,7 +232,7 @@ module Mongoid # :nodoc:
     ##
     # Returns this document's siblings
     def siblings
-      siblings_and_self - [self]
+      siblings_and_self.excludes(:id => self.id)
     end
 
     ##
@@ -237,6 +241,12 @@ module Mongoid # :nodoc:
       base_class.where(:parent_id => self.parent_id)
     end
 
+    ##
+    # Is this document a sibling of the other document?
+    def sibling_of?(other)
+      self.parent_id == other.parent_id
+    end
+
     ##
     # Returns all leaves of this document (be careful, currently involves two queries)
     def leaves
@@ -279,11 +289,10 @@ module Mongoid # :nodoc:
       children.destroy_all
     end
 
-    private
-
+  private
     def rearrange
       if self.parent_id
-        self.parent_ids = base_class.find(self.parent_id).parent_ids + [self.parent_id]
+        self.parent_ids = parent.parent_ids + [self.parent_id]
       else
         self.parent_ids = []
       end
@@ -299,6 +308,5 @@ module Mongoid # :nodoc:
     def position_in_tree
       errors.add(:parent_id, :invalid) if self.parent_ids.include?(self.id)
     end
-
-  end
-end
+  end # Tree
+end # Mongoid

data/lib/mongoid/tree/ordering.rb

@@ -0,0 +1,175 @@
+module Mongoid
+  module Tree
+    ##
+    # = Mongoid::Tree::Ordering
+    #
+    # Mongoid::Tree doesn't order the tree by default. To enable ordering of children
+    # include both Mongoid::Tree and Mongoid::Tree::Ordering into your document.
+    #
+    # == Utility methods
+    #
+    # This module adds methods to get related siblings depending on their position:
+    #
+    #    node.lower_siblings
+    #    node.higher_siblings
+    #    node.first_sibling_in_list
+    #    node.last_sibling_in_list
+    #
+    # There are several methods to move nodes around in the list:
+    #
+    #    node.move_up
+    #    node.move_down
+    #    node.move_to_top
+    #    node.move_to_bottom
+    #    node.move_above(other)
+    #    node.move_below(other)
+    #
+    # Additionally there are some methods to check aspects of the document
+    # in the list of children:
+    #
+    #    node.at_top?
+    #    node.at_bottom?
+    module Ordering
+      extend ActiveSupport::Concern
+
+      included do
+        reflect_on_association(:children).options[:default_order] = :position.asc
+
+        field :position, :type => Integer
+
+        before_save :assign_default_position
+        before_save :reposition_former_siblings, :if => :parent_id_changed?
+        after_destroy :move_lower_siblings_up
+      end
+
+      ##
+      # Returns siblings below the current document.
+      # Siblings with a position greater than this documents's position.
+      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.
+      def higher_siblings
+        self.siblings.where(:position.lt => self.position)
+      end
+
+      ##
+      # Returns the lowest sibling (could be self)
+      def last_sibling_in_list
+        siblings_and_self.asc(:position).last
+      end
+
+      ##
+      # Returns the highest sibling (could be self)
+      def first_sibling_in_list
+        siblings_and_self.asc(:position).first
+      end
+
+      ##
+      # Is this the highest sibling?
+      def at_top?
+        higher_siblings.empty?
+      end
+
+      ##
+      # Is this the lowest sibling?
+      def at_bottom?
+        lower_siblings.empty?
+      end
+
+      ##
+      # Move this node above all its siblings
+      def move_to_top
+        return true if at_top?
+        move_above(first_sibling_in_list)
+      end
+
+      ##
+      # Move this node below all its siblings
+      def move_to_bottom
+        return true if at_bottom?
+        move_below(last_sibling_in_list)
+      end
+
+      ##
+      # Move this node one position up
+      def move_up
+        return if at_top?
+        siblings.where(:position => self.position - 1).first.inc(:position, 1)
+        inc(:position, -1)
+      end
+
+      ##
+      # Move this node one position down
+      def move_down
+        return if at_bottom?
+        siblings.where(:position => self.position + 1).first.inc(:position, -1)
+        inc(:position, 1)
+      end
+
+      ##
+      # Move this node above the specified node
+      #
+      # This method changes the node's parent if nescessary.
+      def move_above(other)
+        update_attributes!(:parent_id => other.parent_id) unless 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) }
+          other.inc(:position, 1)
+          update_attributes!(:position => new_position)
+        else
+          new_position = other.position - 1
+          other.higher_siblings.where(:position.gt => self.position).each { |s| s.inc(:position, -1) }
+          update_attributes!(:position => new_position)
+        end
+      end
+
+      ##
+      # Move this node below the specified node
+      #
+      # This method changes the node's parent if nescessary.
+      def move_below(other)
+        update_attributes!(:parent_id => other.parent_id) unless 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) }
+          update_attributes!(:position => new_position)
+        else
+          new_position = other.position
+          other.higher_siblings.where(:position.gt => self.position).each { |s| s.inc(:position, -1) }
+          other.inc(:position, -1)
+          update_attributes!(:position => new_position)
+        end
+      end
+
+    private
+
+      def move_lower_siblings_up
+        lower_siblings.each { |s| s.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) }
+      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
+        else
+          self.position = self.siblings.max(:position) + 1
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/tree/traversal.rb

@@ -3,7 +3,7 @@ module Mongoid # :nodoc:
     ##
     # = Mongoid::Tree::Traversal
     #
-    # Mongoid::Tree provides a #traverse method to walk through the tree.
+    # Mongoid::Tree::Traversal provides a #traverse method to walk through the tree.
     # It supports these traversal methods:
     #
     # * depth_first

data/spec/mongoid/tree/ordering_spec.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+
+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
+  end
+
+  describe 'when saved' do
+    before(:each) do
+      setup_ordered_tree <<-ENDTREE
+        - root:
+          - child:
+            - subchild:
+              - subsubchild
+        - other_root:
+          - other_child
+          - another_child
+      ENDTREE
+    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
+    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
+    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
+      other_root.children << child
+      child.reload
+      child.position.should == 2
+    end
+
+    it "should correctly reposition siblings when one of them is removed" do
+      node(:other_child).destroy
+      node(:another_child).position.should == 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
+    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
+    end
+  end
+
+  describe 'destroy strategies' do
+    before(:each) do
+      setup_ordered_tree <<-ENDTREE
+        - root:
+          - child:
+            - subchild
+          - other_child
+        - other_root
+      ENDTREE
+    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)]
+      end
+    end
+  end
+
+  describe 'utility methods' do
+    before(:each) do
+      setup_ordered_tree <<-ENDTREE
+        - first_root:
+          - first_child_of_first_root
+          - second_child_of_first_root
+        - second_root
+        - third_root
+      ENDTREE
+    end
+
+    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 == []
+      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)]
+      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
+      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
+      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
+      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
+      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)
+      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)
+      end
+    end
+  end
+
+  describe 'moving nodes around', :focus => true do
+    before(:each) do
+      setup_ordered_tree <<-ENDTREE
+        - first_root:
+          - first_child_of_first_root
+          - second_child_of_first_root
+        - second_root:
+          - first_child_of_second_root
+        - third_root:
+          - first
+          - second
+          - third
+      ENDTREE
+    end
+
+    describe '#move_below' 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)
+        new_parent = node(:second_root)
+        node_to_move.move_below(node(:first_child_of_second_root))
+        node(:second_child_of_first_root).position.should == 0
+      end
+
+      it 'should work when moving to a different parent' do
+        node_to_move = node(:first_child_of_first_root)
+        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
+      end
+
+      it 'should be able to move the first node below the second node' do
+        first_node = node(:first_root)
+        second_node = node(:second_root)
+        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]
+      end
+
+      it 'should be able to move the last node below the first node' do
+        first_node = node(:first_root)
+        last_node = node(:third_root)
+        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]
+      end
+    end
+
+    describe '#move_above' 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)
+        new_parent = node(:second_root)
+        node_to_move.move_above(node(:first_child_of_second_root))
+        node(:second_child_of_first_root).position.should == 0
+      end
+
+      it 'should work when moving to a different parent' do
+        node_to_move = node(:first_child_of_first_root)
+        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
+      end
+
+      it 'should be able to move the last node above the second node' do
+        last_node = node(:third_root)
+        second_node = node(:second_root)
+        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)]
+      end
+
+      it 'should be able to move the first node above the last node' do
+        first_node = node(:first_root)
+        last_node = node(:third_root)
+        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)]
+      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
+      end
+
+      it "should be able to move the last sibling to the top" do
+        first_node = node(:first_root)
+        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)]
+      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
+      end
+
+      it "should be able to move the first sibling to the bottom" do
+        first_node = node(:first_root)
+        middle_node = node(:second_root)
+        last_node = node(:third_root)
+        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]
+      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)]
+      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)]
+      end
+    end
+  end # moving nodes around
+end # Mongoid::Tree::Ordering

data/spec/mongoid/tree/traversal_spec.rb

@@ -67,6 +67,28 @@ describe Mongoid::Tree::Traversal do
       result.collect { |n| n.name.to_sym }.should == [:node1, :node2, :node3, :node4, :node5, :node6, :node7]
     end
 
+    describe 'with reordered nodes' do
+      before do
+        setup_ordered_tree <<-ENDTREE
+          node1:
+            - node2:
+              - node3
+            - node4:
+              - node6
+              - node5
+            - node7
+        ENDTREE
+        node(:node5).move_above(node(:node6))
+      end
+
+      it 'should return 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]
+      end
+
+    end
+
   end
 
   describe 'breadth first traversal' do

data/spec/mongoid/tree_spec.rb

@@ -28,6 +28,14 @@ describe Mongoid::Tree do
     Node.index_options.should have_key(:parent_ids)
   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
+    end
+  end
+
   describe 'when saved' do
 
     before(:each) do
@@ -92,7 +100,6 @@ describe Mongoid::Tree do
       child.should_not be_valid
       child.errors[:parent_id].should_not be_nil
     end
-
   end
 
   describe 'when subclassed' do
@@ -276,8 +283,19 @@ describe Mongoid::Tree do
       end
 
       it "#siblings_and_self should return the documents siblings and itself" do
+        node(:child).siblings_and_self.is_a?(Mongoid::Criteria).should == true
         node(:child).siblings_and_self.to_a.should == [node(:child), node(:other_child)]
       end
+
+      describe '#sibling_of?' do
+        it "should return true for siblings" do
+          node(:child).should 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))
+        end
+      end
     end
 
     describe '#leaves' do

data/spec/support/macros/tree_macros.rb

@@ -3,42 +3,45 @@ require 'yaml'
 module Mongoid::Tree::TreeMacros
 
   def setup_tree(tree)
-    create_tree(YAML.load(tree))
+    create_tree(YAML.load(tree), {:ordered => false})
+  end
+
+  def setup_ordered_tree(tree)
+    create_tree(YAML.load(tree), {:ordered => true})
   end
 
   def node(name)
     @nodes[name].reload
   end
 
-  def print_tree(node, print_ids = false, depth = 0)
+  def print_tree(node, inspect = false, depth = 0)
     print '  ' * depth
     print '- ' unless depth == 0
     print node.name
-    print " (#{node.id})" if print_ids
+    print " (#{node.inspect})" if inspect
     print ':' if node.children.any?
     print "\n"
-    node.children.each { |c| print_tree(c, print_ids, depth + 1) }
+    node.children.each { |c| print_tree(c, inspect, depth + 1) }
   end
 
-  private
-
-  def create_tree(object)
+private
+  def create_tree(object, opts={})
     case object
-      when String: return create_node(object)
-      when Array: object.each { |tree| create_tree(tree) }
+      when String: return create_node(object, opts)
+      when Array: object.each { |tree| create_tree(tree, opts) }
       when Hash:
         name, children = object.first
-        node = create_node(name)
-        children.each { |c| node.children << create_tree(c) }
+        node = create_node(name, opts)
+        children.each { |c| node.children << create_tree(c, opts) }
         return node
     end
   end
 
-  def create_node(name)
+  def create_node(name, opts={})
+    node_class = opts[:ordered] ? OrderedNode : Node
     @nodes ||= HashWithIndifferentAccess.new
-    @nodes[name] = Node.create(:name => name)
+    @nodes[name] = node_class.create(:name => name)
   end
-
 end
 
 RSpec.configure do |config|

data/spec/support/models/node.rb

@@ -1,6 +1,7 @@
 class Node
   include Mongoid::Document
   include Mongoid::Tree
+  include Mongoid::Tree::Traversal
 
   field :name
 end
@@ -8,3 +9,6 @@ end
 class SubclassedNode < Node
 end
 
+class OrderedNode < Node
+  include Mongoid::Tree::Ordering
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mongoid-tree
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Benedikt Deicke
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-09 00:00:00 +02:00
+date: 2010-11-03 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,14 +26,14 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 62196417
+        hash: 62196427
         segments: 
         - 2
         - 0
         - 0
         - beta
-        - 17
-        version: 2.0.0.beta.17
+        - 20
+        version: 2.0.0.beta.20
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,16 +42,13 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 62196423
+        hash: 3
         segments: 
         - 2
         - 0
-        - 0
-        - beta
-        - 18
-        version: 2.0.0.beta.18
+        version: "2.0"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -97,8 +94,10 @@ extra_rdoc_files:
 - README.rdoc
 - LICENSE
 files: 
+- lib/mongoid/tree/ordering.rb
 - lib/mongoid/tree/traversal.rb
 - lib/mongoid/tree.rb
+- spec/mongoid/tree/ordering_spec.rb
 - spec/mongoid/tree/traversal_spec.rb
 - spec/mongoid/tree_spec.rb
 - spec/spec_helper.rb