mongoid-ancestry-fixes 0.0.1 → 0.0.2

data/lib/mongoid-ancestry/exceptions.rb

@@ -1,6 +0,0 @@
-module Mongoid
-  module Ancestry
-    class Error < RuntimeError; end
-    class IntegrityError < RuntimeError; end
-  end
-end

data/lib/mongoid-ancestry/instance_methods.rb

@@ -1,248 +0,0 @@
-module Mongoid
-  module Ancestry
-
-    # Validate that the ancestors don't include itself
-    def ancestry_exclude_self
-      if ancestor_ids.include? id
-        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?
-                  id.to_s
-                else
-                  "#{read_attribute self.class.ancestry_field}/#{id}"
-                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?
-        id.to_s
-      else
-        "#{self.send "#{self.base_class.ancestry_field}_was"}/#{id}"
-      end
-    end
-
-    # Scope
-    def current_search_scope
-      self.embedded? ? self._parent.send(self.base_class.to_s.tableize) : self.base_class
-    end
-
-    # Ancestors
-    def ancestor_ids
-      read_attribute(self.base_class.ancestry_field).to_s.split('/').map { |id| cast_primary_key(id) }
-    end
-
-    def ancestor_conditions
-      { :_id.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 + [id]
-    end
-
-    def path_conditions
-      { :_id.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 : current_search_scope.find(parent_id)
-    end
-
-    def parent_id
-      ancestor_ids.empty? ? nil : ancestor_ids.last
-    end
-
-    def parent
-      parent_id.blank? ? nil : current_search_scope.find(parent_id)
-    end
-
-    # Root
-    def root_id
-      (root_id == id) ? self : current_search.find(root_id)
-    end
-
-    def root
-      (root_id == id) ? self : current_search_scope.find(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
-      current_search_scope.where(child_conditions)
-    end
-
-    def child_ids
-      children.only(:_id).map(&:id)
-    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(:_id).map(&:id)
-    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 => /^#{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(:_id).map(&:id)
-    end
-
-    # Subtree
-    def subtree_conditions
-      [
-        { :_id => id },
-        { 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).only(:_id).map(&:id)
-    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
-
-    private
-
-    def cast_primary_key(key)
-      if primary_key_type == Integer
-        key.to_i
-      elsif primary_key_type == BSON::ObjectId && key =~ /[a-z0-9]{24}/
-        BSON::ObjectId.convert(self, key)
-      else
-        key
-      end
-    end
-
-    def primary_key_type
-      @primary_key_type ||= self.base_class.fields['_id'].options[:type]
-    end
-  end
-
-end

data/lib/mongoid-ancestry/version.rb

@@ -1,5 +0,0 @@
-module Mongoid
-  module Ancestry
-    VERSION = '0.2.3'
-  end
-end

data/log/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore

data/mongoid-ancestry.gemspec

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "mongoid-ancestry/version"
-
-Gem::Specification.new do |s|
-  s.name        = 'mongoid-ancestry-fixes'
-  s.version     = '0.0.1'
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Stefan Kroes", "Anton Orel"]
-  s.email       = ["eagle.anton@gmail.com"]
-  s.description = %q{Organise Mongoid model into a tree structure}
-  s.homepage    = "http://github.com/skyeagle/mongoid-ancestry"
-  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.licenses    = ["MIT"]
-
-  s.rubyforge_project = "mongoid-ancestry-fixes"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.extra_rdoc_files = [
-    "README.md"
-  ]
-
-  s.add_dependency('mongoid', ">= 2.0")
-  s.add_dependency('bson_ext', ">= 1.3")
-end
-

data/spec/lib/ancestry_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-require 'mongoid-ancestry/exceptions'
-
-
-describe MongoidAncestry do
-
-  subject { MongoidAncestry }
-
-  it "should have ancestry fields" do
-    subject.with_model do |model|
-      model.fields['ancestry'].options[:type].should eql(String)
-    end
-  end
-
-  it "should have non default ancestry field" do
-    subject.with_model :ancestry_field => :alternative_ancestry do |model|
-      model.ancestry_field.should eql(:alternative_ancestry)
-    end
-  end
-
-  it "should set ancestry field" do
-    subject.with_model do |model|
-      model.ancestry_field = :ancestors
-      model.ancestry_field.should eql(:ancestors)
-      model.ancestry_field = :ancestry
-      model.ancestry_field.should eql(:ancestry)
-    end
-  end
-
-  it "should have default orphan strategy" do
-    subject.with_model do |model|
-      model.orphan_strategy.should eql(:destroy)
-    end
-  end
-
-  it "should have non default orphan strategy" do
-    subject.with_model :orphan_strategy => :rootify do |model|
-      model.orphan_strategy.should eql(:rootify)
-    end
-  end
-
-  it "should set orphan strategy" do
-    subject.with_model do |model|
-      model.orphan_strategy = :rootify
-      model.orphan_strategy.should eql(:rootify)
-      model.orphan_strategy = :destroy
-      model.orphan_strategy.should eql(:destroy)
-    end
-  end
-
-  it "should not set invalid orphan strategy" do
-    subject.with_model do |model|
-      expect {
-        model.orphan_strategy = :non_existent_orphan_strategy
-      }.to raise_error Mongoid::Ancestry::Error
-    end
-  end
-
-  it "should setup test nodes" do
-    subject.with_model :depth => 3, :width => 3 do |model, roots|
-      roots.class.should eql(Array)
-      roots.length.should eql(3)
-      roots.each do |node, children|
-        node.class.should eql(model)
-        children.class.should eql(Array)
-        children.length.should eql(3)
-        children.each do |node, children|
-          node.class.should eql(model)
-          children.class.should eql(Array)
-          children.length.should eql(3)
-          children.each do |node, children|
-            node.class.should eql(model)
-            children.class.should eql(Array)
-            children.length.should eql(0)
-          end
-        end
-      end
-    end
-  end
-
-  it "should have STI support" do
-    subject.with_model :extra_columns => {:type => :string} do |model|
-      subclass1 = Object.const_set 'Subclass1', Class.new(model)
-      (class << subclass1; self; end).send(:define_method, :model_name) do
-      Struct.new(:human, :underscore).new 'Subclass1', 'subclass1'
-      end
-      subclass2 = Object.const_set 'Subclass2', Class.new(model)
-      (class << subclass2; self; end).send(:define_method, :model_name) do
-      Struct.new(:human, :underscore).new 'Subclass1', 'subclass1'
-      end
-
-      node1 = subclass1.create
-      node2 = subclass2.create :parent => node1
-      node3 = subclass1.create :parent => node2
-      node4 = subclass2.create :parent => node3
-      node5 = subclass1.create :parent => node4
-
-      model.all.each do |node|
-        [subclass1, subclass2].include?(node.class).should be_true
-      end
-
-      node1.descendants.map(&:id).should eql([node2.id, node3.id, node4.id, node5.id])
-      node1.subtree.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id, node5.id])
-      node5.ancestors.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id])
-      node5.path.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id, node5.id])
-    end
-  end
-
-end

data/spec/lib/mongoid-ancestry/class_methods_spec.rb

@@ -1,300 +0,0 @@
-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 {|a, b|; a.to_param <=> b.to_param }
-      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 => [:_id, :desc]
-      ascending_nodes_lvl0 = model.arrange :order => [:_id, :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 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|
-      node = roots.first.first
-      node.without_ancestry_callbacks do
-       node.update_attribute model.ancestry_field, 35
-      end
-      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.id
-      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).id).id)
-      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.id
-      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).id).id)
-      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