mongoid-ancestry 0.1.0

data/lib/mongoid/ancestry/instance_methods.rb

@@ -0,0 +1,246 @@
+module Mongoid
+  module Ancestry
+    module InstanceMethods
+      def save!(opts = {})
+        opts.merge!(:safe => true)
+        retries = 3
+        begin
+          super(opts)
+        rescue Mongo::OperationFailure => e
+          (retries -= 1) > 0 && e.to_s =~ %r{duplicate key error.+\$#{self.base_class.uid_field}} ? retry : raise(e)
+        end
+      end
+      alias_method :save, :save!
+
+      def set_uid
+        previous = self.class.desc(:"#{self.base_class.uid_field}").first
+        uniq_id = previous ? previous.read_attribute(:"#{uid_field}").to_i + 1 : 1
+        send :"#{uid_field}=", uniq_id
+      end
+
+      # Validate that the ancestors don't include itself
+      def ancestry_exclude_self
+        if ancestor_ids.include? read_attribute(self.base_class.uid_field)
+          errors.add(:base, "#{self.class.name.humanize} cannot be a descendant of itself.")
+        end
+      end
+
+      # Update descendants with new ancestry
+      def update_descendants_with_new_ancestry
+        # Skip this if callbacks are disabled
+        unless ancestry_callbacks_disabled?
+          # If node is valid, not a new record and ancestry was updated ...
+          if changed.include?(self.base_class.ancestry_field.to_s) && !new_record? && valid?
+            # ... for each descendant ...
+            descendants.each do |descendant|
+              # ... replace old ancestry with new ancestry
+              descendant.without_ancestry_callbacks do
+                for_replace = \
+                  if read_attribute(self.class.ancestry_field).blank?
+                    read_attribute(self.base_class.uid_field).to_s
+                  else
+                    "#{read_attribute self.class.ancestry_field }/#{uid}"
+                  end
+                new_ancestry = descendant.read_attribute(descendant.class.ancestry_field).gsub(/^#{self.child_ancestry}/, for_replace)
+                descendant.update_attribute(self.base_class.ancestry_field, new_ancestry)
+              end
+            end
+          end
+        end
+      end
+
+      # Apply orphan strategy
+      def apply_orphan_strategy
+        # Skip this if callbacks are disabled
+        unless ancestry_callbacks_disabled?
+          # If this isn't a new record ...
+          unless new_record?
+            # ... make al children root if orphan strategy is rootify
+            if self.base_class.orphan_strategy == :rootify
+              descendants.each do |descendant|
+                descendant.without_ancestry_callbacks do
+                  val = \
+                    unless descendant.ancestry == child_ancestry
+                      descendant.read_attribute(descendant.class.ancestry_field).gsub(/^#{child_ancestry}\//, '')
+                    end
+                  descendant.update_attribute descendant.class.ancestry_field, val
+                end
+              end
+              # ... destroy all descendants if orphan strategy is destroy
+            elsif self.base_class.orphan_strategy == :destroy
+              descendants.all.each do |descendant|
+                descendant.without_ancestry_callbacks { descendant.destroy }
+              end
+              # ... throw an exception if it has children and orphan strategy is restrict
+            elsif self.base_class.orphan_strategy == :restrict
+              raise Error.new('Cannot delete record because it has descendants.') unless is_childless?
+            end
+          end
+        end
+      end
+
+      # The ancestry value for this record's children
+      def child_ancestry
+        # New records cannot have children
+        raise Error.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
+
+        if self.send("#{self.base_class.ancestry_field}_was").blank?
+          read_attribute(self.base_class.uid_field).to_s
+        else
+          "#{self.send "#{self.base_class.ancestry_field}_was"}/#{read_attribute(self.base_class.uid_field)}"
+        end
+      end
+
+      # Ancestors
+      def ancestor_ids
+        read_attribute(self.base_class.ancestry_field).to_s.split('/').map{ |uid| uid.to_i }
+      end
+
+      def ancestor_conditions
+        {self.base_class.uid_field.in => ancestor_ids}
+      end
+
+      def ancestors depth_options = {}
+        self.base_class.scope_depth(depth_options, depth).where(ancestor_conditions)
+      end
+
+      def path_ids
+        ancestor_ids + [read_attribute(self.base_class.uid_field)]
+      end
+
+      def path_conditions
+        {self.base_class.uid_field.in => path_ids}
+      end
+
+      def path depth_options = {}
+        self.base_class.scope_depth(depth_options, depth).where(path_conditions)
+      end
+
+      def depth
+        ancestor_ids.size
+      end
+
+      def cache_depth
+        write_attribute self.base_class.depth_cache_field, depth
+      end
+
+      # Parent
+      def parent= parent
+        write_attribute(self.base_class.ancestry_field, parent.blank? ? nil : parent.child_ancestry)
+      end
+
+      def parent_id= parent_id
+        self.parent = parent_id.blank? ? nil : self.base_class.find_by_uid!(parent_id)
+      end
+
+      def parent_id
+        ancestor_ids.empty? ? nil : ancestor_ids.last
+      end
+
+      def parent
+        parent_id.blank? ? nil : self.base_class.find_by_uid!(parent_id)
+      end
+
+      # Root
+      def root_id
+        ancestor_ids.empty? ? read_attribute(self.base_class.uid_field) : ancestor_ids.first
+      end
+
+      def root
+        (root_id == read_attribute(self.base_class.uid_field)) ? self : self.base_class.find_by_uid!(root_id)
+      end
+
+      def is_root?
+        read_attribute(self.base_class.ancestry_field).blank?
+      end
+
+      # Children
+      def child_conditions
+        {self.base_class.ancestry_field => child_ancestry}
+      end
+
+      def children
+        self.base_class.where(child_conditions)
+      end
+
+      def child_ids
+        children.only(self.base_class.uid_field).all.map(&self.base_class.uid_field)
+      end
+
+      def has_children?
+        self.children.present?
+      end
+
+      def is_childless?
+        !has_children?
+      end
+
+      # Siblings
+      def sibling_conditions
+        {self.base_class.ancestry_field => read_attribute(self.base_class.ancestry_field)}
+      end
+
+      def siblings
+        self.base_class.where sibling_conditions
+      end
+
+      def sibling_ids
+        siblings.only(self.base_class.uid_field).all.collect(&self.base_class.uid_field)
+      end
+
+      def has_siblings?
+        self.siblings.count > 1
+      end
+
+      def is_only_child?
+        !has_siblings?
+      end
+
+      # Descendants
+      def descendant_conditions
+        #["#{self.base_class.ancestry_field} like ? or #{self.base_class.ancestry_column} = ?", "#{child_ancestry}/%", child_ancestry]
+        [
+          { self.base_class.ancestry_field => /^#{child_ancestry}\// },
+          { self.base_class.ancestry_field => child_ancestry }
+        ]
+      end
+
+      def descendants depth_options = {}
+        self.base_class.scope_depth(depth_options, depth).any_of(descendant_conditions)
+      end
+
+      def descendant_ids depth_options = {}
+        descendants(depth_options).only(self.base_class.uid_field).collect(&self.base_class.uid_field)
+      end
+
+      # Subtree
+      def subtree_conditions
+        #["#{self.base_class.primary_key} = ? or #{self.base_class.ancestry_column} like ? or #{self.base_class.ancestry_column} = ?", self.id, "#{child_ancestry}/%", child_ancestry]
+          [
+            { self.base_class.uid_field => read_attribute(self.base_class.uid_field) },
+            { self.base_class.ancestry_field => /^#{child_ancestry}\// },
+            { self.base_class.ancestry_field => child_ancestry }
+          ]
+      end
+
+      def subtree depth_options = {}
+        self.base_class.scope_depth(depth_options, depth).any_of(subtree_conditions)
+      end
+
+      def subtree_ids depth_options = {}
+        subtree(depth_options).select(self.base_class.uid_field).all.collect(&self.base_class.uid_field)
+      end
+
+      # Callback disabling
+      def without_ancestry_callbacks
+        @disable_ancestry_callbacks = true
+        yield
+        @disable_ancestry_callbacks = false
+      end
+
+      def ancestry_callbacks_disabled?
+        !!@disable_ancestry_callbacks
+      end
+    end
+  end
+end

data/lib/mongoid/ancestry.rb

@@ -0,0 +1,14 @@
+module Mongoid
+  module Ancestry
+    extend ActiveSupport::Concern
+
+    autoload :ClassMethods,    'mongoid/ancestry/class_methods'
+    autoload :InstanceMethods, 'mongoid/ancestry/instance_methods'
+    autoload :Error,           'mongoid/ancestry/exceptions'
+
+    included do
+      cattr_accessor :base_class
+      self.base_class = self
+    end
+  end
+end

data/mongoid-ancestry.gemspec

@@ -0,0 +1,125 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongoid-ancestry}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stefan Kroes", "Anton Orel"]
+  s.date = %q{2011-04-16}
+  s.description = %q{Organise Mongoid model into a tree structure}
+  s.email = %q{eagle.anton@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "MIT-LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "init.rb",
+    "install.rb",
+    "lib/mongoid/ancestry.rb",
+    "lib/mongoid/ancestry/class_methods.rb",
+    "lib/mongoid/ancestry/exceptions.rb",
+    "lib/mongoid/ancestry/instance_methods.rb",
+    "log/.gitkeep",
+    "mongoid-ancestry.gemspec",
+    "spec/mongoid/ancestry/class_methods_spec.rb",
+    "spec/mongoid/ancestry/instance_methods_spec.rb",
+    "spec/mongoid/ancestry_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/models.rb"
+  ]
+  s.homepage = %q{http://github.com/skyeagle/mongoid-ancestry}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{'Ancestry allows the records of a Mongoid model to be organised in a tree structure, using a single, intuitively formatted database field. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.'}
+  s.test_files = [
+    "spec/mongoid/ancestry/class_methods_spec.rb",
+    "spec/mongoid/ancestry/instance_methods_spec.rb",
+    "spec/mongoid/ancestry_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/models.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mongoid-ancestry>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<guard-rspec>, ["~> 0.2"])
+      s.add_development_dependency(%q<libnotify>, ["~> 0.3"])
+      s.add_development_dependency(%q<rb-inotify>, ["~> 0.8"])
+      s.add_development_dependency(%q<fuubar>, ["~> 0.0.4"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<guard-rspec>, ["~> 0.2"])
+      s.add_development_dependency(%q<libnotify>, ["~> 0.3"])
+      s.add_development_dependency(%q<rb-inotify>, ["~> 0.8"])
+      s.add_development_dependency(%q<fuubar>, ["~> 0.0.4"])
+      s.add_runtime_dependency(%q<mongoid>, ["~> 2.0"])
+      s.add_runtime_dependency(%q<bson_ext>, ["~> 1.3"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<guard-rspec>, ["~> 0.2"])
+      s.add_development_dependency(%q<libnotify>, ["~> 0.3"])
+      s.add_development_dependency(%q<rb-inotify>, ["~> 0.8"])
+      s.add_development_dependency(%q<fuubar>, ["~> 0.0.4"])
+    else
+      s.add_dependency(%q<mongoid-ancestry>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<guard-rspec>, ["~> 0.2"])
+      s.add_dependency(%q<libnotify>, ["~> 0.3"])
+      s.add_dependency(%q<rb-inotify>, ["~> 0.8"])
+      s.add_dependency(%q<fuubar>, ["~> 0.0.4"])
+      s.add_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<guard-rspec>, ["~> 0.2"])
+      s.add_dependency(%q<libnotify>, ["~> 0.3"])
+      s.add_dependency(%q<rb-inotify>, ["~> 0.8"])
+      s.add_dependency(%q<fuubar>, ["~> 0.0.4"])
+      s.add_dependency(%q<mongoid>, ["~> 2.0"])
+      s.add_dependency(%q<bson_ext>, ["~> 1.3"])
+      s.add_dependency(%q<rspec>, ["~> 2.5"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<guard-rspec>, ["~> 0.2"])
+      s.add_dependency(%q<libnotify>, ["~> 0.3"])
+      s.add_dependency(%q<rb-inotify>, ["~> 0.8"])
+      s.add_dependency(%q<fuubar>, ["~> 0.0.4"])
+    end
+  else
+    s.add_dependency(%q<mongoid-ancestry>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.5"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<guard-rspec>, ["~> 0.2"])
+    s.add_dependency(%q<libnotify>, ["~> 0.3"])
+    s.add_dependency(%q<rb-inotify>, ["~> 0.8"])
+    s.add_dependency(%q<fuubar>, ["~> 0.0.4"])
+    s.add_dependency(%q<rspec>, ["~> 2.5"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<guard-rspec>, ["~> 0.2"])
+    s.add_dependency(%q<libnotify>, ["~> 0.3"])
+    s.add_dependency(%q<rb-inotify>, ["~> 0.8"])
+    s.add_dependency(%q<fuubar>, ["~> 0.0.4"])
+    s.add_dependency(%q<mongoid>, ["~> 2.0"])
+    s.add_dependency(%q<bson_ext>, ["~> 1.3"])
+    s.add_dependency(%q<rspec>, ["~> 2.5"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<guard-rspec>, ["~> 0.2"])
+    s.add_dependency(%q<libnotify>, ["~> 0.3"])
+    s.add_dependency(%q<rb-inotify>, ["~> 0.8"])
+    s.add_dependency(%q<fuubar>, ["~> 0.0.4"])
+  end
+end
+

data/spec/mongoid/ancestry/class_methods_spec.rb

@@ -0,0 +1,305 @@
+require 'spec_helper'
+
+describe MongoidAncestry do
+
+  subject { MongoidAncestry }
+
+  it "should have scopes" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      # Roots assertion
+      model.roots.all.to_a.should eql(roots.map(&:first))
+
+      model.all.each do |test_node|
+        # Assertions for ancestors_of named scope
+        model.ancestors_of(test_node).all.should == test_node.ancestors.all
+        model.ancestors_of(test_node.id).all.to_a.should eql(test_node.ancestors.all.to_a)
+        # Assertions for children_of named scope
+        model.children_of(test_node).all.to_a.should eql(test_node.children.all.to_a)
+        model.children_of(test_node.id).all.to_a.should eql(test_node.children.all.to_a)
+        # Assertions for descendants_of named scope
+        model.descendants_of(test_node).all.should == (test_node.descendants.all)
+        model.descendants_of(test_node.id).all.to_a.should eql(test_node.descendants.all.to_a)
+        # Assertions for subtree_of named scope
+        model.subtree_of(test_node).all.to_a.should eql(test_node.subtree.all.to_a)
+        model.subtree_of(test_node.id).all.to_a.should eql(test_node.subtree.all.to_a)
+        # Assertions for siblings_of named scope
+        model.siblings_of(test_node).all.to_a.should eql(test_node.siblings.all.to_a)
+        model.siblings_of(test_node.id).all.to_a.should eql(test_node.siblings.all.to_a)
+      end
+    end
+  end
+
+  it "should be arranged" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      id_sorter = Proc.new do |a, b|; a.uid <=> b.uid; end
+      arranged_nodes = model.arrange
+      arranged_nodes.size.should eql(3)
+      arranged_nodes.each do |node, children|
+        children.keys.sort(&id_sorter).should eql(node.children.sort(&id_sorter))
+        children.each do |node, children|
+          children.keys.sort(&id_sorter).should eql(node.children.sort(&id_sorter))
+          children.each do |node, children|
+            children.size.should eql(0)
+          end
+        end
+      end
+    end
+  end
+
+  it "should have arrange order option" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      descending_nodes_lvl0 = model.arrange :order => [:uid, :desc]
+      ascending_nodes_lvl0 = model.arrange :order => [:uid, :asc]
+
+      descending_nodes_lvl0.keys.zip(ascending_nodes_lvl0.keys.reverse).each do |descending_node, ascending_node|
+        ascending_node.should eql(descending_node)
+        descending_nodes_lvl1 = descending_nodes_lvl0[descending_node]
+        ascending_nodes_lvl1 = ascending_nodes_lvl0[ascending_node]
+        descending_nodes_lvl1.keys.zip(ascending_nodes_lvl1.keys.reverse).each do |descending_node, ascending_node|
+          ascending_node.should eql(descending_node)
+          descending_nodes_lvl2 = descending_nodes_lvl1[descending_node]
+          ascending_nodes_lvl2 = ascending_nodes_lvl1[ascending_node]
+          descending_nodes_lvl2.keys.zip(ascending_nodes_lvl2.keys.reverse).each do |descending_node, ascending_node|
+            ascending_node.should eql(descending_node)
+            descending_nodes_lvl3 = descending_nodes_lvl2[descending_node]
+            ascending_nodes_lvl3 = ascending_nodes_lvl2[ascending_node]
+            descending_nodes_lvl3.keys.zip(ascending_nodes_lvl3.keys.reverse).each do |descending_node, ascending_node|
+              ascending_node.should eql(descending_node)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  it "should have valid orphan rootify strategy" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      model.orphan_strategy = :rootify
+      root = roots.first.first
+      children = root.children.all
+      root.destroy
+      children.each do |child|
+        child.reload
+        child.is_root?.should be_true
+        child.children.size.should eql(3)
+      end
+    end
+  end
+
+  it "should have valid orphan destroy strategy" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      model.orphan_strategy = :destroy
+      root = roots.first.first
+      expect { root.destroy }.to change(model, :count).by(-root.subtree.size)
+      node = model.roots.first.children.first
+      expect { node.destroy }.to change(model, :count).by(-node.subtree.size)
+    end
+  end
+
+  it "should have valid orphan restrict strategy" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      model.orphan_strategy = :restrict
+      root = roots.first.first
+      expect { root.destroy }.to raise_error Mongoid::Ancestry::Error
+      expect { root.children.first.children.first.destroy }.to_not raise_error Mongoid::Ancestry::Error
+    end
+  end
+
+  it "should find record by uid" do
+    subject.with_model do |model|
+      expect { model.find_by_uid!(1)}.to raise_error(Mongoid::Errors::DocumentNotFound)
+      instance = model.create!
+      expect { model.find_by_uid!(1).should eql(instance)}.to_not raise_error(Mongoid::Errors::DocumentNotFound)
+    end
+  end
+
+  it "should check that there are no errors on a valid tree" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      expect { model.check_ancestry_integrity! }.to_not raise_error(Mongoid::Ancestry::Error)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(0)
+    end
+  end
+
+  it "should check detection of invalid format for ancestry field" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 'invalid_ancestry'
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  it "should check detection of non-existent ancestor" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 35
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  it "should check detection of cyclic ancestry" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      node = roots.first.first
+      node.update_attribute model.ancestry_field, node.uid
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  it "should check detection of conflicting parent id" do
+    subject.with_model do |model|
+      model.destroy_all
+      model.create!(model.ancestry_field => model.create!(model.ancestry_field => model.create!(model.ancestry_field => nil).uid).uid)
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  def assert_integrity_restoration model
+    expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+    model.restore_ancestry_integrity!
+    expect { model.check_ancestry_integrity! }.to_not raise_error(Mongoid::Ancestry::IntegrityError)
+  end
+
+  it "should check that integrity is restored for invalid format for ancestry field" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 'invalid_ancestry'
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should check that integrity is restored for non-existent ancestor" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 35
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should check that integrity is restored for cyclic ancestry" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      node = roots.first.first
+      node.update_attribute model.ancestry_field, node.uid
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should check that integrity is restored for conflicting parent id" do
+    subject.with_model do |model|
+      model.destroy_all
+      model.create!(model.ancestry_field => model.create!(model.ancestry_field => model.create!(model.ancestry_field => nil).uid).uid)
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should create node through scope" do
+    subject.with_model do |model|
+      node = model.create!
+      child = node.children.create # doesn't pass with .create!
+      child.parent.should eql(node)
+
+      other_child = child.siblings.create # doesn't pass with .create!
+      other_child.parent.should eql(node)
+
+      grandchild = model.children_of(child).build # doesn't pass with .new
+      grandchild.save
+      grandchild.parent.should eql(child)
+
+      other_grandchild = model.siblings_of(grandchild).build # doesn't pass with .new
+      other_grandchild.save!
+      other_grandchild.parent.should eql(child)
+    end
+  end
+
+  it "should have depth scopes" do
+    subject.with_model :depth => 4, :width => 2, :cache_depth => true do |model, roots|
+      model.before_depth(2).all? { |node| node.depth < 2 }.should be_true
+      model.to_depth(2).all?     { |node| node.depth <= 2 }.should be_true
+      model.at_depth(2).all?     { |node| node.depth == 2 }.should be_true
+      model.from_depth(2).all?   { |node| node.depth >= 2 }.should be_true
+      model.after_depth(2).all?  { |node| node.depth > 2 }.should be_true
+    end
+  end
+
+  it "should raise error on invalid scopes" do
+    subject.with_model do |model|
+      expect { model.before_depth(1) } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.to_depth(1)     } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.at_depth(1)     } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.from_depth(1)   } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.after_depth(1)  } .to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+  it "should raise error on invalid has_ancestry options" do
+    subject.with_model do |model|
+      expect { model.has_ancestry :this_option_doesnt_exist => 42 }.to raise_error(Mongoid::Ancestry::Error)
+      expect { model.has_ancestry :not_a_hash                     }.to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+  it "should build ancestry from parent ids" do
+    subject.with_model :skip_ancestry => true, :extra_columns => {:parent_id => :integer} do |model|
+      [model.create!].each do |parent1|
+        (Array.new(5) { model.create :parent_id => parent1.id }).each do |parent2|
+          (Array.new(5) { model.create :parent_id => parent2.id }).each do |parent3|
+            (Array.new(5) { model.create :parent_id => parent3.id })
+          end
+        end
+      end
+
+      # Assert all nodes where created
+      model.count.should eql((0..3).map { |n| 5 ** n }.sum)
+    end
+
+    subject.with_model do |model|
+
+      model.build_ancestry_from_parent_ids!
+
+      # Assert ancestry integrity
+      model.check_ancestry_integrity!
+
+      roots = model.roots.all
+      ## Assert single root node
+      roots.size.should eql(1)
+
+      ## Assert it has 5 children
+      roots.each do |parent|
+        parent.children.count.should eql(5)
+        parent.children.each do |parent|
+          parent.children.count.should eql(5)
+          parent.children.each do |parent|
+            parent.children.count.should eql(5)
+            parent.children.each do |parent|
+              parent.children.count.should eql(0)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  it "should rebuild depth cache" do
+    subject.with_model :depth => 3, :width => 3, :cache_depth => true, :depth_cache_field => :depth_cache do |model, roots|
+      model.update_all(:depth_cache => nil)
+
+      # Assert cache was emptied correctly
+      model.all.each do |test_node|
+        test_node.depth_cache.should eql(nil)
+      end
+
+      # Rebuild cache
+      model.rebuild_depth_cache!
+
+      # Assert cache was rebuild correctly
+      model.all.each do |test_node|
+        test_node.depth_cache.should eql(test_node.depth)
+      end
+    end
+  end
+
+  it "should raise exception when rebuilding depth cache for model without depth caching" do
+    subject.with_model do |model|
+      expect { model.rebuild_depth_cache! }.to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+end