acts_as_ordered_tree 0.0.7 → 1.0.3

data/lib/acts_as_ordered_tree/validators.rb

@@ -0,0 +1,15 @@
+module ActsAsOrderedTree
+  module Validators #:nodoc:all:
+    class CyclicReferenceValidator < ActiveModel::Validator
+      def validate(record)
+        record.errors.add(:parent, :invalid) if record.is_or_is_ancestor_of?(record.parent)
+      end
+    end
+
+    class ScopeValidator < ActiveModel::Validator
+      def validate(record)
+        record.errors.add(:parent, :scope) unless record.same_scope?(record.parent)
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/version.rb

@@ -1,3 +1,3 @@
 module ActsAsOrderedTree
-  VERSION = "0.0.7"
+  VERSION = "1.0.3"
 end

data/spec/acts_as_ordered_tree_spec.rb

@@ -1,314 +1,819 @@
-require File.expand_path('../test_helper', __FILE__)
+require File.expand_path('../spec_helper', __FILE__)
 
 describe ActsAsOrderedTree do
-  before :all do
-    root   = Node.create(:name => "Root")
-    child1 = Node.create(:parent_id => root.id, :name => "Child 1")
-    child2 = Node.create(:parent_id => root.id, :name => "Child 2")
-
-    Node.create(:parent_id => child1.id, :name => "Subchild 1")
-    Node.create(:parent_id => child1.id, :name => "Subchild 2")
-    Node.create(:parent_id => child2.id, :name => "Subchild 3")
+  describe "defaults" do
+    subject { Default }
+
+    its(:parent_column) { should eq :parent_id }
+    its(:position_column) { should eq :position }
+    its(:depth_column) { should eq :depth }
+    its(:children_counter_cache_column) { be_nil }
+
+    context "instance" do
+      subject { Default.new }
+
+      it { should_not allow_mass_assignment_of(:position) }
+      it { should_not allow_mass_assignment_of(:depth) }
+    end
+  end
+
+  describe "default with counter cache" do
+    subject { DefaultWithCounterCache }
+
+    its(:children_counter_cache_column) { should eq :categories_count }
   end
 
-  let(:root) { Node.where(:parent_id => nil).first }
-  let(:branch) { Node.where(:parent_id => root.id).first }
-  let(:second_branch) { Node.where(:parent_id => root.id).last }
-  let(:leaf) { Node.where(:parent_id => branch.id).first }
-  let(:last) { Node.last }
-  let(:blank) { Node.new(:parent_id => branch.id) }
+  describe "renamed columns" do
+    subject { RenamedColumns }
+
+    its(:parent_column) { should eq :mother_id }
+    its(:position_column) { should eq :red }
+    its(:depth_column) { should eq :pitch }
+
+    context "instance" do
+      subject { RenamedColumns.new }
 
-  describe "class" do
-    it "should be properly configured" do
-      Node.position_column.should eq(:position)
-      Node.parent_column.should eq(:parent_id)
+      it { should_not allow_mass_assignment_of(:red) }
+      it { should_not allow_mass_assignment_of(:pitch) }
     end
+  end
+
+  it "creation_with_altered_column_names" do
+    lambda {
+      RenamedColumns.create!()
+    }.should_not raise_exception
+  end
 
-    it "should have roots" do
-      Node.roots.count.should eq(1)
-      Node.roots.first.should eq(root)
-      Node.root.should eq(root)
+  describe ".roots" do
+    # create fixture
+    before { FactoryGirl.create_list(:default, 3) }
+
+    subject { Default.roots }
+
+    its(:entries) { should eq Default.where(:parent_id => nil).order(:position).to_a }
+  end
+
+  describe ".leaves" do
+    # create fixture
+    let(:root) { create :default_with_counter_cache }
+    before { create_list :default_with_counter_cache, 2, :parent => root }
+
+    subject { DefaultWithCounterCache }
+
+    it { should respond_to(:leaves) }
+    its(:leaves) { should have(2).items }
+  end
+
+  describe ".root" do
+    # create fixture
+    let!(:root) { create :default }
+
+    context "given a single root node" do
+      subject { root }
+
+      its(:position) { should eq 1 }
+    end
+
+    context "given multiple root nodes" do
+      before { create_list :default, 3 }
+
+      subject { Default }
+
+      its(:root) { should eq root }
     end
   end
 
-  describe "tree" do
-    it "should have roots" do
-      root.root.should eq(root)
-      branch.root.should eq(root)
-      leaf.root.should eq(root)
+  describe "#root?, #child?, #leaf?, #branch? and #root" do
+    shared_examples "tree with predicates" do |factory_name|
+      # create fixture
+      let!(:root) { create factory_name }
+      let!(:child) { create factory_name, :parent => root }
+      let!(:grandchild) { create factory_name, :parent => child }
+
+      before { root.reload }
+      before { child.reload }
+      before { grandchild.reload }
+
+      context "given root node" do
+        subject { root }
+
+        it { should be_root }
+        it { should_not be_child }
+        it { should_not be_leaf }
+        it { should be_branch }
+        its(:root) { should eq root }
+        its(:level) { should eq 0 }
+      end
+
+      context "given a branch node with children" do
+        subject { child }
+
+        it { should_not be_root }
+        it { should be_child }
+        it { should_not be_leaf }
+        it { should be_branch }
+        its(:root) { should eq root }
+        its(:level) { should eq 1 }
+      end
+
+      context "given a leaf node" do
+        subject { grandchild }
+
+        it { should_not be_root }
+        it { should be_child }
+        it { should be_leaf }
+        it { should_not be_branch }
+        its(:root) { should eq root }
+        its(:level) { should eq 2 }
+      end
+
+      context "given a new record" do
+        subject { build factory_name }
+
+        it { should_not be_leaf }
+        it { should be_branch }
+      end
     end
 
-    it "should have children" do
-      root.children.count.should eq(2)
-      branch.children.count.should eq(2)
-      leaf.children.count.should eq(0)
+    it_behaves_like "tree with predicates", :default
+    it_behaves_like "tree with predicates", :default_with_counter_cache
+  end
+
+  describe "#first?, #last?" do
+    let!(:root)    { create :default }
+    let!(:child_1) { create :default, :parent => root }
+    let!(:child_2) { create :default, :parent => root }
+    let!(:child_3) { create :default, :parent => root }
+
+    context "given a node without siblings" do
+      subject { root }
+
+      it { should be_first }
+      it { should be_last }
     end
 
-    it "should have parents" do
-      root.parent.should be(nil)
-      branch.parent.should eq(root)
-      leaf.parent.should eq(branch)
+    context "given a node, first in the list" do
+      subject { child_1 }
+
+      it { should be_first }
+      it { should_not be_last }
     end
 
-    it "should return true if root" do
-      root.root?.should be(true)
-      branch.root?.should be(false)
-      leaf.root?.should be(false)
+    context "given a node, nor first neither last" do
+      subject { child_2 }
+
+      it { should_not be_first }
+      it { should_not be_last }
     end
 
-    it "should return true if leaf" do
-      root.leaf?.should be(false)
-      branch.leaf?.should be(false)
-      leaf.leaf?.should be(true)
+    context "given a node, last in the list" do
+      subject { child_3 }
+
+      it { should_not be_first }
+      it { should be_last }
     end
+  end
+
+  describe "#level" do
+    context "given a persistent root node" do
+      subject { create :default }
 
-    it "should tell about node's depth" do
-      root.depth.should eq(0)
-      branch.depth.should eq(1)
-      leaf.depth.should eq(2)
+      its(:level) { should eq 0 }
     end
+    context "given a new root record" do
+      subject { build :default }
 
-    it "should iterate over ancestors" do
-      leaf.self_and_ancestors.should have(3).items
-      leaf.ancestors.should have(2).items
-      branch.ancestors.should have(1).items
-      root.ancestors.should have(0).items
+      its(:level) { should eq 0 }
+    end
+    context "given a persistent node with parent" do
+      let(:root) { create :default }
+      subject { create :default, :parent => root }
+      its(:level) { should eq 1 }
+    end
+    context "given a new node with parent" do
+      let(:root) { create :default }
+      subject { build :default, :parent => root }
+      its(:level) { should eq 1 }
     end
+  end
+
+  describe "#self_and_ancestors" do
+    # create fixture
+    let!(:root) { create :default }
+    let!(:child) { create :default, :parent => root }
+    let!(:grandchild) { create :default, :parent => child }
+
+    context "leaf" do
+      subject { grandchild.self_and_ancestors }
+
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(3).items }
+      its(:first) { should eq root }
+      its(:last) { should eq subject }
+    end
+
+    context "child" do
+      subject { child.self_and_ancestors }
+
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(2).items }
+      its(:first) { should eq root }
+      its(:last) { should eq subject }
+    end
+
+    context "root" do
+      subject { root.self_and_ancestors }
+
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(1).item }
+      its(:first) { should eq root }
+    end
+  end
+
+  describe "#ancestors" do
+    # create fixture
+    let!(:root) { create :default }
+    let!(:child) { create :default, :parent => root }
+    let!(:grandchild) { create :default, :parent => child }
+
+    context "leaf" do
+      subject { grandchild.ancestors }
+
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(2).items }
+      its(:first) { should eq root }
+      its(:last) { should eq child }
+    end
+
+    context "child" do
+      subject { child.ancestors }
+
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(1).item }
+      its(:first) { should eq root }
+    end
+
+    context "root" do
+      subject { root.ancestors }
+
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should be_empty }
+    end
+  end
 
-    it "should iterate over descendants" do
-      root.self_and_descendants.should have(6).items
+  describe "#self_and_descendants" do
+    # create fixture
+    let!(:root) { create :default }
+    let!(:child) { create :default, :parent => root }
+    let!(:grandchild) { create :default, :parent => child }
 
-      root.descendants.should have(5).items
-      root.descendants.first.should eq(branch)
-      root.descendants.last.should eq(last)
+    context "leaf" do
+      subject { grandchild.self_and_descendants }
 
-      branch.descendants.should have(2).items
-      branch.descendants.first.should eq(leaf)
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(1).item }
+      its(:first) { should eq grandchild }
+    end
+
+    context "child" do
+      subject { child.self_and_descendants }
 
-      leaf.descendants.should have(0).items
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(2).items }
+      its(:first) { should eq child }
+      its(:last) { should eq grandchild }
     end
 
-    it "should have siblings" do
-      branch.self_and_siblings.should have(2).items
-      branch.self_and_siblings.should include(branch)
+    context "root" do
+      subject { root.self_and_descendants }
 
-      branch.siblings.should have(1).item
-      branch.siblings.should_not include(branch)
+      it { should be_a ActiveRecord::Relation }
+      it { should be_loaded }
+      it { should have(3).items }
+      its(:first) { should eq root }
+      its(:last) { should eq grandchild }
     end
   end
 
-  describe "list" do
-    it "should be ordered" do
-      root.position.should eq(1)
-      root.children.first.position.should eq(1)
-      root.children.last.position.should eq(2)
+  describe "#is_descendant_of?, #is_or_is_descendant_of?, #is_ancestor_of?, #is_or_is_ancestor_of?" do
+    # create fixture
+    let!(:root) { create :default }
+    let!(:child) { create :default, :parent => root }
+    let!(:grandchild) { create :default, :parent => child }
+
+    context "grandchild" do
+      subject { grandchild }
+
+      it { should be_is_descendant_of(root) }
+      it { should be_is_or_is_descendant_of(root) }
+      it { should_not be_is_ancestor_of(root) }
+      it { should_not be_is_or_is_ancestor_of(root) }
+
+      it { should be_is_descendant_of(child) }
+      it { should be_is_or_is_descendant_of(child) }
+      it { should_not be_is_ancestor_of(child) }
+      it { should_not be_is_or_is_ancestor_of(child) }
+
+      it { should_not be_is_descendant_of(grandchild) }
+      it { should be_is_or_is_descendant_of(grandchild) }
+      it { should_not be_is_ancestor_of(grandchild) }
+      it { should be_is_or_is_ancestor_of(grandchild) }
+    end
+
+    context "child" do
+      subject { child }
+
+      it { should be_is_descendant_of(root) }
+      it { should be_is_or_is_descendant_of(root) }
+      it { should_not be_is_ancestor_of(root) }
+      it { should_not be_is_or_is_ancestor_of(root) }
+
+      it { should_not be_is_descendant_of(child) }
+      it { should be_is_or_is_descendant_of(child) }
+      it { should_not be_is_ancestor_of(child) }
+      it { should be_is_or_is_ancestor_of(child) }
+
+      it { should_not be_is_descendant_of(grandchild) }
+      it { should_not be_is_or_is_descendant_of(grandchild) }
+      it { should be_is_ancestor_of(grandchild) }
+      it { should be_is_or_is_ancestor_of(grandchild) }
     end
 
-    it "should be sortable through scope" do
-      Node.where(:parent_id => root.id).ordered.first.should eq(branch)
+    context "root" do
+      subject { root }
+
+      it { should_not be_is_descendant_of(root) }
+      it { should be_is_or_is_descendant_of(root) }
+      it { should_not be_is_ancestor_of(root) }
+      it { should be_is_or_is_ancestor_of(root) }
+
+      it { should_not be_is_descendant_of(child) }
+      it { should_not be_is_or_is_descendant_of(child) }
+      it { should be_is_ancestor_of(child) }
+      it { should be_is_or_is_ancestor_of(child) }
+
+      it { should_not be_is_descendant_of(grandchild) }
+      it { should_not be_is_or_is_descendant_of(grandchild) }
+      it { should be_is_ancestor_of(grandchild) }
+      it { should be_is_or_is_ancestor_of(grandchild) }
     end
   end
 
-  describe "mutations" do
-    around(:each) do |example|
-      Node.transaction do
-        example.run
+  describe "#left_sibling" do
+    shared_examples "tree with siblings" do
+      subject { items }
+
+      its('first.left_sibling') { should be_nil }
+      its('first.right_sibling') { should eq items.second }
+
+      its('second.left_sibling') { should eq items.first }
+      its('second.right_sibling') { should eq items.last }
 
-        raise ActiveRecord::Rollback
+      its('third.left_sibling') { should eq items.second }
+      its('third.right_sibling') { should be_nil }
+    end
+
+    context "given unscoped tree" do
+      it_should_behave_like "tree with siblings" do
+        let(:items) { create_list :default, 3 }
       end
     end
 
-    it "should be placed to the bottom of the list" do
-      blank.save
-      branch.children.last.should eq(blank)
+    context "given scoped tree" do
+      let!(:items_1) { create_list :scoped, 3, :scope_type => "s1" }
+      let!(:items_2) { create_list :scoped, 3, :scope_type => "s2" }
+
+      it_should_behave_like "tree with siblings" do
+        let(:items) { items_1 }
+      end
+      it_should_behave_like "tree with siblings" do
+        let(:items) { items_2 }
+      end
     end
+  end
 
-    it "should be placed to the middle of the list" do
-      blank.position = 2
-      blank.save
+  describe "#reload_node" do
+    let!(:node) { create :default }
 
-      blank.position.should eq(2)
-      blank.siblings.should have(2).items
-      blank.siblings.last.position.should eq(3)
+    before do
+      node.name = 'changed'
+      node.parent_id = 200
+      node.position = 1000
     end
 
-    it "should be movable inside parent" do
-      last_child = branch.children.last
+    subject { node.send :reload_node }
 
-      blank.save
-      blank.move_higher
+    its(:name) { should eq 'changed' }
+    its(:parent_id) { should be_nil }
+    its(:position) { should eq 1 }
+  end
+
+  describe "move actions" do
+    let!(:root) { create :default_with_counter_cache, :name => 'root' }
+    let!(:child_1) { create :default_with_counter_cache, :parent => root, :name => 'child_1' }
+    let!(:child_2) { create :default_with_counter_cache, :parent => root, :name => 'child_2' }
+    let!(:child_3) { create :default_with_counter_cache, :parent => root, :name => 'child_3' }
 
-      blank.position.should eq(2)
-      last_child.reload.position.should eq(3)
+    context "initial" do
+      specify { expect([child_1, child_2, child_3]).to be_sorted }
 
-      blank.move_lower
-      blank.position.should eq(3)
+      subject { root.reload }
+      its(:parent_id) { should be_nil }
+      its(:level) { should be_zero }
+      its(:position) { should eq 1 }
+      its(:categories_count) { should eq 3}
     end
 
-    it "should be movable to bottom of its parent" do
-      first_child = branch.children.first
+    context "on_save_when_parent_changed" do
+      example "move_1_to_root" do
+        child_1.parent = nil
+        child_1.save
+        expect(child_1.position).to eq 2
+        expect([root, child_1]).to be_sorted
+      end
 
-      first_child.move_to_bottom
-      first_child.position.should eq(2)
-      first_child.reload.position.should eq(2)
+      example "move_3_to_root" do
+        child_3.parent = nil
+        child_3.save
+        expect(child_3.position).to eq 2
+        expect([root, child_3]).to be_sorted
+      end
     end
 
-    it "should be movable to top of its parent" do
-      first_child = branch.children.first
-      last_child = branch.children.last
+    describe "#move_left" do
+      example "move_1_left" do
+        expect{ child_1.move_left }.to raise_exception ActiveRecord::ActiveRecordError
+        expect([child_1, child_2, child_3]).to be_sorted
+      end
 
-      last_child.move_to_top
+      example "move_2_left" do
+        child_2.move_left
+        expect([child_2, child_1, child_3]).to be_sorted
+      end
+
+      example "move_3_left" do
+        child_3.move_left
+        expect([child_1, child_3, child_2]).to be_sorted
+      end
+    end
+
+    describe "#move_right" do
+      example "move_3_right" do
+        expect{ child_3.move_right }.to raise_exception ActiveRecord::ActiveRecordError
+        expect([child_1, child_2, child_3]).to be_sorted
+      end
 
-      last_child.position.should eq(1)
-      last_child.reload.position.should eq(1)
+      example "move_2_right" do
+        child_2.move_right
+        expect([child_1, child_3, child_2]).to be_sorted
+      end
 
-      first_child.reload.position.should eq(2)
+      example "move_1_right" do
+        child_1.move_right
+        expect([child_2, child_1, child_3]).to be_sorted
+      end
     end
 
-    it "should shift up lower items when parent is changed" do
-      first_child = branch.children.first
-      last_child = branch.children.last
-      
-      # move to other parent
-      first_child.parent = second_branch
-      first_child.should be_parent_changed
+    describe "#move_to_left_of" do
+      example "move_3_to_left_of_1" do
+        child_3.move_to_left_of child_1
+        expect([child_3, child_1, child_2]).to be_sorted
+      end
+
+      example "move_3_to_left_of_2" do
+        child_3.move_to_left_of child_2
+        expect([child_1, child_3, child_2]).to be_sorted
+      end
 
-      first_child.save
+      example "move_1_to_left_of_3" do
+        child_1.move_to_left_of child_3
+        expect([child_2, child_1, child_3]).to be_sorted
+      end
 
-      # old sibling should shift up
-      last_child.reload.position.should eq(1)
+      example "move_1_to_left_of_3_id" do
+        child_1.move_to_left_of child_3.id
+        expect([child_2, child_1, child_3]).to be_sorted
+      end
+
+      example "move_root_to_left_of_child_2" do
+        expect{ root.move_to_left_of child_2 }.to raise_exception ActiveRecord::ActiveRecordError
+      end
     end
 
-    it "should save its previous position when parent is changed" do
-      first_child = branch.children.first
+    describe "#move_to_right_of" do
+      example "move_1_to_right_of_2" do
+        child_1.move_to_right_of child_2
+        expect([child_2, child_1, child_3]).to be_sorted
+      end
 
-      first_child.parent = second_branch
-      first_child.save
+      example "move_1_to_right_of_3" do
+        child_1.move_to_right_of child_3
+        expect([child_2, child_3, child_1]).to be_sorted
+      end
 
-      first_child.position.should eq(1)
-      last.position.should eq(2)
+      example "move_1_to_right_of_3_id" do
+        child_1.move_to_right_of child_3.id
+        expect([child_2, child_3, child_1]).to be_sorted
+      end
+
+      example "move_3_to_right_of_1" do
+        child_3.move_to_right_of child_1
+        expect([child_1, child_3, child_2]).to be_sorted
+      end
+
+      example "move_root_to_right_of_child_2" do
+        expect{ root.move_to_right_of child_2 }.to raise_exception ActiveRecord::ActiveRecordError
+      end
     end
 
-    it "should be movable to last position of new parent" do
-      first_child = branch.children.first
+    describe "#move_to_root" do
+      before { child_2.move_to_root }
+
+      context "child_2" do
+        subject { child_2 }
 
-      first_child.move_to_child_of(second_branch)
-      first_child.parent.should eq(second_branch)
-      first_child.should be_last
+        its(:level) { should be_zero }
+        its(:parent_id) { should be_nil }
+        its(:position) { should eq 2 }
+
+        it "should not become new root" do
+          DefaultWithCounterCache.root.should eq root
+        end
+      end
+
+      context "other_nodes" do
+        specify { child_1.reload.position.should eq 1 }
+        specify { child_3.reload.position.should eq 2 }
+        specify { root.reload.categories_count.should eq 2 }
+      end
+
+
+      context "given a root node" do
+        before { root.move_to_root }
+        subject { root }
+
+        its(:position) { should eq 1 }
+
+        it "positions should not change" do
+          expect([root, child_3]).to be_sorted
+        end
+      end
     end
 
-    it "should be movable to above of some node" do
-      first_child = branch.children.first
-      above_of    = second_branch.children.first
+    describe "#move_to_child_of" do
+      let(:moved_child) { create :default_with_counter_cache, :name => 'moved_child' }
 
-      first_child.move_to_above_of(above_of)
-      first_child.parent.should eq(second_branch)
-      
-      first_child.position.should eq(1)
-      above_of.position.should eq(2)
+      before { moved_child.move_to_child_of root }
+      context "moved_child" do
+        subject { moved_child }
+        its(:level) { should eq 1 }
+        its(:position) { should eq 4 }
+      end
+
+      context "root" do
+        subject { root.reload }
+        its(:right_sibling) { should be_nil }
+        its(:categories_count) { should eq 4 }
+      end
+
+      context "given a node which already is children of target" do
+        subject { child_2 }
+        before { child_2.move_to_child_of root }
+
+        its(:position) { should eq 2 }
+
+        it "positions_should_not_change" do
+          expect([child_1, child_2, child_3, moved_child]).to be_sorted
+        end
+      end
+
+      it { expect([child_1, child_2, child_3, moved_child]).to be_sorted }
+      it { expect{ root.move_to_child_of root }.to raise_exception ActiveRecord::ActiveRecordError }
+      it { expect{ root.move_to_child_of child_1 }.to raise_exception ActiveRecord::ActiveRecordError }
     end
 
-    it "should be movable to bottom of some node" do
-      second = second_branch
+    describe "#move_to_child_with_index" do
+      let(:moved_child) { create :default, :name => 'moved_child' }
+
+      example "move_to_child_as_first" do
+        moved_child.move_to_child_with_index root, 0
+        expect([moved_child, child_1, child_2, child_3]).to be_sorted
+        moved_child.position.should eq 1
+      end
+
+      example "move_to_child_as_second" do
+        moved_child.move_to_child_with_index root, 1
+        expect([child_1, moved_child, child_2, child_3]).to be_sorted
+        moved_child.position.should eq 2
+      end
+
+      example "move_to_child_as_third" do
+        moved_child.move_to_child_with_index root, 2
+        expect([child_1, child_2, moved_child, child_3]).to be_sorted
+        moved_child.position.should eq 3
+      end
+
+      example "move_to_child_as_last" do
+        moved_child.move_to_child_with_index root, 3
+        expect([child_1, child_2, child_3, moved_child]).to be_sorted
+        moved_child.position.should eq 4
+      end
+
+      example "move_child_to_root_as_first" do
+        child_3.move_to_child_with_index nil, 0
+        child_3.level.should be_zero
+        expect([child_3, root, moved_child]).to be_sorted
+        expect([child_1, child_2]).to be_sorted
+        child_2.right_sibling.should be_nil
+      end
+
+      example "move_to_child_with_large_index" do
+        moved_child.move_to_child_with_index root, 100
+        expect([child_1, child_2, child_3, moved_child]).to be_sorted
+        moved_child.position.should eq 4
+      end
+
+      example "move_to_child_with_negative_index" do
+        moved_child.move_to_child_with_index root, -2
+        expect([child_1, child_2, moved_child, child_3]).to be_sorted
+        moved_child.position.should eq 3
+      end
+
+      example "move_to_child_with_large_negative_index" do
+        expect{ moved_child.move_to_child_with_index root, -100 }.to raise_exception ActiveRecord::ActiveRecordError
+      end
 
-      first_child = branch.children.first
+      example "move_to_child_with_nil_index" do
+        expect{ moved_child.move_to_child_with_index root, nil }.to raise_exception ActiveRecord::ActiveRecordError
+      end
 
-      first_child.move_to_bottom_of(branch)
-      first_child.parent.should eq(branch.parent)
+      example "move_to_child_with_float_index" do
+        moved_child.move_to_child_with_index root, 1.7
+        expect([child_1, moved_child, child_2, child_3]).to be_sorted
+      end
+
+      example "move_root_to_child_of_self" do
+        expect{ root.move_to_child_with_index child_1, 1 }.to raise_exception ActiveRecord::ActiveRecordError
+      end
 
-      first_child.position.should eq(2)
-      second.reload.position.should eq(3)
     end
 
-    it "should shift up lower items on destroy" do
-      branch.children.first.destroy
+    describe "#insert_at" do
+      before { child_3.insert_at(1) }
+      before { child_3.reload }
 
-      branch.children.should have(1).items
-      branch.children.first.position.should eq(1)
+      specify { expect([child_3, child_1, child_2]).to be_sorted }
     end
 
     describe "callbacks" do
-      it "should fire *_reorder callbacks when position (but not parent) changes" do
-        examples_count = 6
+      subject { child_3 }
+
+      it { should fire_callback(:before_move).when_calling(:move_to_root).once }
+      it { should fire_callback(:after_move).when_calling(:move_to_root).once }
+      it { should fire_callback(:around_move).when_calling(:move_to_root).once }
+
+      it { should_not fire_callback(:before_move).when_calling(:move_left) }
+      it { should_not fire_callback(:after_move).when_calling(:move_left) }
+      it { should_not fire_callback(:around_move).when_calling(:move_left) }
+
+      it { should fire_callback(:before_reorder).when_calling(:move_higher).once }
+      it { should fire_callback(:after_reorder).when_calling(:move_higher).once }
+
+      it { should_not fire_callback(:before_reorder).when_calling(:move_to_root) }
 
-        second_branch.should_receive(:on_before_reorder).exactly(examples_count)
-        second_branch.should_receive(:on_around_reorder).exactly(examples_count)
-        second_branch.should_receive(:on_after_reorder).exactly(examples_count)
+      it "should cache depth on save" do
+        record = build :default_with_counter_cache
 
-        second_branch.move_higher
-        second_branch.move_lower
-        second_branch.move_to_top
-        second_branch.move_to_bottom
-        second_branch.decrement_position
-        second_branch.increment_position
+        record.depth.should be_nil
+        record.save
+
+        record.depth.should eq 0
+
+        record.move_to_left_of child_3
+        record.depth.should eq child_3.level
       end
 
-      it "should not fire *_reorder callbacks when parent_changes" do
-        leaf.should_not_receive(:on_before_reorder)
-        leaf.should_not_receive(:on_around_reorder)
-        leaf.should_not_receive(:on_after_reorder)
+      it "should recalculate depth of descendants" do
+        record = create :default_with_counter_cache, :parent => child_3
+        record.depth.should eq 2
 
-        p1 = leaf.parent
-        p2 = second_branch
+        child_3.move_to_root
+        record.reload.depth.should eq 1
 
-        leaf.move_to_child_of(p2)
-        leaf.move_to_above_of(p1.children.first)
-        leaf.move_to_child_of(p2)
-        leaf.move_to_bottom_of(p1.children.first)
+        child_3.move_to_child_of child_1
+        record.reload.depth.should eq 3
       end
+    end
+
+  end
 
-      it "should not fire *_reorder callbacks when position is not changed" do
-        leaf.should_not_receive(:on_before_reorder)
-        leaf.should_not_receive(:on_around_reorder)
-        leaf.should_not_receive(:on_after_reorder)
+  describe "scoped trees" do
+    let!(:root1) { create :scoped, :scope_type => "t1" }
+    let!(:child1) { create :scoped, :parent => root1 }
+    let!(:orphan) do
+      record = create :scoped, :parent => root1
+      record.class.update_all({:scope_type => "t0", :position => 1}, {:id => record.id})
+      record
+    end
 
-        last.should_not_receive(:on_before_reorder)
-        last.should_not_receive(:on_around_reorder)
-        last.should_not_receive(:on_after_reorder)
+    let!(:root2) { create :scoped, :scope_type => "t2" }
+    let!(:child2) { create :scoped, :scope_type => "t2", :parent => root2 }
 
-        leaf.move_higher
-        last.move_lower
+    it "should not stick positions together for different scopes" do
+      root1.position.should eq root2.position
+    end
+    it "should automatically set scope for new records with parent" do
+      child1.should be_same_scope(root1)
+    end
+    it "should not include orphans" do
+      root1.children.reload.should_not include orphan
+      root1.descendants.reload.should_not include orphan
+    end
+    it "should not allow to move records between scopes" do
+      expect { child2.move_to_child_of root1 }.to raise_error(ActiveRecord::ActiveRecordError)
+    end
+    it "should not allow to change scope" do
+      child2.parent = root1
+      child2.should have_at_least(1).error_on(:parent)
+    end
+    it "should not allow to add scoped record to children collection" do
+      root1.children << child2
+      root1.children.reload.should_not include child2
+    end
+  end
 
-        leaf.save
-        last.save
-      end
+  describe "#destroy behavior" do
+    let!(:root) { create :default_with_counter_cache, :name => 'root' }
+    let!(:child_1) { create :default_with_counter_cache, :parent => root, :name => 'child_1' }
+    let!(:child_2) { create :default_with_counter_cache, :parent => root, :name => 'child_2' }
+    let!(:child_3) { create :default_with_counter_cache, :parent => root, :name => 'child_3' }
 
-      it "should fire *_move callbacks when parent is changed" do
-        examples_count = 3
-        leaf.should_receive(:on_before_move).exactly(examples_count)
-        leaf.should_receive(:on_after_move).exactly(examples_count)
-        leaf.should_receive(:on_around_move).exactly(examples_count)
+    describe "it should destroy descendants" do
+      subject { root }
+      before { subject.destroy }
 
-        p1 = leaf.parent
-        p2 = second_branch
+      it { should be_destroyed }
+      its('descendants.reload') { should be_empty }
 
-        leaf.move_to_child_of(p2)
-        leaf.move_to_above_of(p1)
-        leaf.move_to_bottom_of(p1.children.first)
+      specify "ensure the loneliness" do
+        root.class.all.should be_empty
       end
+    end
+
+    describe "it should stick positions together" do
+      before { child_2.destroy }
+      before { child_3.reload }
+
+      subject { child_3 }
 
-      it "should not fire *_move callbacks when parent is not changed" do
-        leaf.should_not_receive(:on_before_move)
-        leaf.should_not_receive(:on_after_move)
-        leaf.should_not_receive(:on_around_move)
+      its(:left_sibling) { should eq child_1 }
+      its(:position) { should eq 2 }
 
-        leaf.move_to_child_of(leaf.parent)
-        leaf.move_to_above_of(leaf.siblings.first)
-        leaf.move_to_bottom_of(leaf.siblings.first)
-        leaf.reload.save
+      specify "root categories_count should decrease" do
+        root.reload.categories_count.should eq 2
       end
     end
   end
 
-  describe "validations" do
-    it "should not allow to link parent to itself" do
-      branch.parent = branch
-      branch.should_not be_valid
+  describe "potential vulnerabilities" do
+    describe "attempt to link parent to one of descendants" do
+      let(:root) { create :default }
+      let(:child) { create :default, :parent => root }
+      let(:grandchild) { create :default, :parent => child }
+
+      subject { root }
+
+      context "given self as parent" do
+        before { root.parent = root }
+
+        it { should have_at_least(1).error_on(:parent) }
+      end
+
+      context "given child as parent" do
+        before { root.parent = child }
+
+        it { should have_at_least(1).error_on(:parent) }
+      end
+
+      context "given grandchild as parent" do
+        before { root.parent = grandchild }
+
+        it { should have_at_least(1).error_on(:parent) }
+      end
     end
 
-    it "should not allow to link to one of its descendants" do
-      branch.parent = leaf
-      branch.should_not be_valid
+    describe "attempt to create node with wrong position" do
+      it "should not throw error" do
+        expect{ create :default, :position => 22 }.not_to raise_error
+      end
     end
   end
 end