ancestry 1.3.0 → 2.0.0.rc1

data/README.rdoc

@@ -8,8 +8,7 @@ To apply Ancestry to any ActiveRecord model, follow these simple steps:
 
 1. Install
    - <b>Rails 2</b>
-     - Add to config/environment.rb: <b>config.gem 'ancestry'</b>
-     - Install required gems: <b>sudo rake gems:install</b>
+     - See 1-3-stable branch
    - <b>Rails 3</b>
      - Add to Gemfile: <b>gem 'ancestry'</b>
      - Install required gems: <b>bundle install</b>
@@ -46,7 +45,7 @@ To navigate an Ancestry model, use the following methods on any instance / recor
   parent_id        Returns the id of the parent of the record, nil for a root node
   root             Returns the root of the tree the record is in, self for a root node
   root_id          Returns the id of the root of the tree the record is in
-  is_root?         Returns true if the record is a root node, false otherwise
+  root?, is_root?  Returns true if the record is a root node, false otherwise
   ancestor_ids     Returns a list of ancestor ids, starting with the root id and ending with the parent id
   ancestors        Scopes the model on ancestors of the record
   path_ids         Returns a list the path ids, starting with the root id and ending with the node's own id
@@ -74,6 +73,7 @@ The has_ancestry methods supports the following options:
                          :destroy   All children are destroyed as well (default)
                          :rootify   The children of the destroyed node become root nodes
                          :restrict  An AncestryException is raised if any children exist
+                         :adopt     The orphan subtree is added to the parent of the deleted node.If the deleted node is Root, then rootify the orphan subtree.
   :cache_depth           Cache the depth of each node in the 'ancestry_depth' column (default: false)
                          If you turn depth_caching on for an existing model:
                          - Migrate: add_column [table], :ancestry_depth, :integer, :default => 0
@@ -224,7 +224,18 @@ Additionally, if you think something is wrong with your depth cache:
 
 = Tests
 
-The Ancestry gem comes with a unit test suite consisting of about 1800 assertions in about 30 tests. It takes about 10 seconds to run on sqlite. To run it yourself check out the repository from GitHub, copy test/database.example.yml to test/database.yml and type 'rake'. You can pass rake style options for ActiveRecord version to test against (e.g. ar=3.0.1) and database to test against (e.g. db=mysql). The test suite is located in test/has_ancestry_test.rb.
+The Ancestry gem comes with a unit test suite consisting of about 1800 assertions in about 30 tests. It takes about 10 seconds to run on sqlite. To run it yourself:
+- check out the repository from GitHub
+- copy test/database.example.yml to test/database.yml
+- run <tt>bundle</tt>
+- run <tt>rake [test]</tt>
+
+You can pass an environment variable for the database to test against (e.g. db=mysql). By default, the test suite runs against the latest activerecord version. You can run agains activerecord 3-0 or 3-1 as follows:
+- run <tt>bundle --gemfile Gemfile.rails-<version></tt>
+- run <tt>rake [test] BUNDLE_GEMFILE=Gemfile.rails-<version></tt>
+
+To run the test suite multiple times against several databases and all supported activerecord versions, run <tt>rake test_all</tt>
+The test suite is located in test/has_ancestry_test.rb.
 
 = Internals
 
@@ -238,6 +249,14 @@ The materialised path pattern requires Ancestry to use a 'like' condition in ord
 
 The latest version of ancestry is recommended. The three numbers of each version numbers are respectively the major, minor and patch versions. We started with major version 1 because it looks so much better and ancestry was already quite mature and complete when it was published. The major version is only bumped when backwards compatibility is broken. The minor version is bumped when new features are added. The patch version is bumped when bugs are fixed.
 
+- Version 2.0.0.rc1 (2013-05-07)
+  - Removed rails 2 compatibility
+  - Fixed deprecation warnings for rails 4
+  - New adopt strategy
+  - Many more fixes & minor changes
+- Version 1.3.0 (2012-05-04)
+  - Ancestry now ignores default scopes when moving or destroying nodes, ensuring tree consistency
+  - Changed ActiveRecord dependency to 2.3.14
 - Version 1.2.5 (2012-03-15)
   - Fixed warnings: "parenthesize argument(s) for future version"
   - Fixed a bug in the restore_ancestry_integrity! method (thx Arthur Holstvoogd)

data/ancestry.gemspec

@@ -3,7 +3,7 @@ Gem::Specification.new do |s|
   s.description = 'Organise ActiveRecord model into a tree structure'
   s.summary     = 'Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql 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.version = '1.3.0'
+  s.version = '2.0.0.rc1'
 
   s.author   = 'Stefan Kroes'
   s.email    = 's.a.kroes@gmail.com'
@@ -22,5 +22,5 @@ Gem::Specification.new do |s|
     'README.rdoc'
   ]
   
-  s.add_dependency 'activerecord', '>= 2.3.14'
+  s.add_dependency 'activerecord', '>= 3.0.0'
 end

data/lib/ancestry.rb

@@ -2,3 +2,7 @@ require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/class_meth
 require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/instance_methods')
 require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/exceptions')
 require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/has_ancestry')
+
+module Ancestry
+  ANCESTRY_PATTERN = /\A[0-9]+(\/[0-9]+)*\Z/
+end

data/lib/ancestry/class_methods.rb

@@ -2,12 +2,12 @@ module Ancestry
   module ClassMethods
     # Fetch tree node if necessary
     def to_node object
-      if object.is_a?(self.base_class) then object else find(object) end
+      if object.is_a?(self.ancestry_base_class) then object else find(object) end
     end 
     
     # Scope on relative depth options
     def scope_depth depth_options, depth
-      depth_options.inject(self.base_class) do |scope, option|
+      depth_options.inject(self.ancestry_base_class) do |scope, option|
         scope_name, relative_depth = option
         if [:before_depth, :to_depth, :at_depth, :from_depth, :after_depth].include? scope_name
           scope.send scope_name, depth + relative_depth
@@ -19,11 +19,11 @@ module Ancestry
 
     # Orphan strategy writer
     def orphan_strategy= orphan_strategy
-      # Check value of orphan strategy, only rootify, restrict or destroy is allowed
-      if [:rootify, :restrict, :destroy].include? orphan_strategy
+      # Check value of orphan strategy, only rootify, adopt, restrict or destroy is allowed
+      if [:rootify, :adopt, :restrict, :destroy].include? orphan_strategy
         class_variable_set :@@orphan_strategy, orphan_strategy
       else
-        raise Ancestry::AncestryException.new("Invalid orphan strategy, valid ones are :rootify, :restrict and :destroy.")
+        raise Ancestry::AncestryException.new("Invalid orphan strategy, valid ones are :rootify,:adopt, :restrict and :destroy.")
       end
     end
     
@@ -31,12 +31,12 @@ module Ancestry
     def arrange options = {}
       scope =
         if options[:order].nil?
-          self.base_class.ordered_by_ancestry
+          self.ancestry_base_class.ordered_by_ancestry
         else
-          self.base_class.ordered_by_ancestry_and options.delete(:order)
+          self.ancestry_base_class.ordered_by_ancestry_and options.delete(:order)
         end
       # Get all nodes ordered by ancestry and start sorting them into an empty hash
-      arrange_nodes scope.all(options)
+      arrange_nodes scope.where(options)
     end
     
     # Arrange array of nodes into a nested hash of the form 
@@ -57,14 +57,28 @@ module Ancestry
     end
     
     # Pseudo-preordered array of nodes.  Children will always follow parents, 
-    # but the ordering of nodes within a rank depends on their order in the 
-    # array that gets passed in
-    def sort_by_ancestry(nodes)
-      arranged = nodes.is_a?(Hash) ? nodes : arrange_nodes(nodes.sort_by{|n| n.ancestry || '0'})
+    # for ordering nodes within a rank provide block, eg. Node.sort_by_ancestry(Node.all) {|a, b| a.rank <=> b.rank}.
+    def sort_by_ancestry(nodes, &block)
+      arranged = nodes if nodes.is_a?(Hash)
+      
+      unless arranged
+        presorted_nodes = nodes.sort do |a, b|
+          a_cestry, b_cestry = a.ancestry || '0', b.ancestry || '0'
+          
+          if block_given? && a_cestry == b_cestry
+            yield a, b
+          else
+            a_cestry <=> b_cestry
+          end
+        end
+        
+        arranged = arrange_nodes(presorted_nodes)
+      end
+      
       arranged.inject([]) do |sorted_nodes, pair|
         node, children = pair
         sorted_nodes << node
-        sorted_nodes += sort_by_ancestry(children) unless children.blank?
+        sorted_nodes += sort_by_ancestry(children, &block) unless children.blank?
         sorted_nodes
       end
     end
@@ -74,9 +88,9 @@ module Ancestry
       parents = {}
       exceptions = [] if options[:report] == :list
       
-      self.base_class.send(:with_exclusive_scope) do 
+      self.ancestry_base_class.unscoped do 
         # For each node ...
-        self.base_class.find_each do |node|
+        self.ancestry_base_class.find_each do |node|
           begin
             # ... check validity of ancestry column
             if !node.valid? and !node.errors[node.class.ancestry_column].blank?
@@ -111,10 +125,10 @@ module Ancestry
     def restore_ancestry_integrity!
       parents = {}
       # Wrap the whole thing in a transaction ...
-      self.base_class.transaction do
-        self.base_class.send(:with_exclusive_scope) do 
+      self.ancestry_base_class.transaction do
+        self.ancestry_base_class.unscoped do 
           # For each node ...
-          self.base_class.find_each do |node|
+          self.ancestry_base_class.find_each do |node|
             # ... set its ancestry to nil if invalid
             if !node.valid? and !node.errors[node.class.ancestry_column].blank?
               node.without_ancestry_callbacks do
@@ -133,7 +147,7 @@ module Ancestry
           end
           
           # For each node ...
-          self.base_class.find_each do |node|
+          self.ancestry_base_class.find_each do |node|
             # ... rebuild ancestry from parents array
             ancestry, parent = nil, parents[node.id]
             until parent.nil?
@@ -149,8 +163,8 @@ module Ancestry
     
     # Build ancestry from parent id's for migration purposes
     def build_ancestry_from_parent_ids! parent_id = nil, ancestry = nil
-      self.base_class.send(:with_exclusive_scope) do 
-        self.base_class.find_each(:conditions => {:parent_id => parent_id}) do |node|
+      self.ancestry_base_class.unscoped do 
+        self.ancestry_base_class.where(:parent_id => parent_id).find_each do |node|
           node.without_ancestry_callbacks do
             node.update_attribute ancestry_column, ancestry
           end
@@ -163,8 +177,8 @@ module Ancestry
     def rebuild_depth_cache!
       raise Ancestry::AncestryException.new("Cannot rebuild depth cache for model without depth caching.") unless respond_to? :depth_cache_column
       
-      self.base_class.send(:with_exclusive_scope) do 
-        self.base_class.find_each do |node|
+      self.ancestry_base_class.unscoped do 
+        self.ancestry_base_class.find_each do |node|
           node.update_attribute depth_cache_column, node.depth
         end
       end

data/lib/ancestry/has_ancestry.rb

@@ -3,7 +3,7 @@ class << ActiveRecord::Base
     # Check options
     raise Ancestry::AncestryException.new("Options for has_ancestry must be in a hash.") unless options.is_a? Hash
     options.each do |key, value|
-      unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :primary_key_format].include? key
+      unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column].include? key
         raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
       end
     end
@@ -23,32 +23,24 @@ class << ActiveRecord::Base
     self.orphan_strategy = options[:orphan_strategy] || :destroy
 
     # Save self as base class (for STI)
-    cattr_accessor :base_class
-    self.base_class = self
+    cattr_accessor :ancestry_base_class
+    self.ancestry_base_class = self
     
     # Validate format of ancestry column value
-    primary_key_format = options[:primary_key_format] || /[0-9]+/
-    validates_format_of ancestry_column, :with => /\A#{primary_key_format.source}(\/#{primary_key_format.source})*\Z/, :allow_nil => true
+    validates_format_of ancestry_column, :with => Ancestry::ANCESTRY_PATTERN, :allow_nil => true
 
     # Validate that the ancestor ids don't include own id
     validate :ancestry_exclude_self
     
-    # Save ActiveRecord version
-    self.cattr_accessor :rails_3
-    self.rails_3 = defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
-    
-    # Workaround to support Rails 2
-    scope_method = if rails_3 then :scope else :named_scope end
-
     # Named scopes
-    send scope_method, :roots, :conditions => {ancestry_column => nil}
-    send scope_method, :ancestors_of, lambda { |object| {:conditions => to_node(object).ancestor_conditions} }
-    send scope_method, :children_of, lambda { |object| {:conditions => to_node(object).child_conditions} }
-    send scope_method, :descendants_of, lambda { |object| {:conditions => to_node(object).descendant_conditions} }
-    send scope_method, :subtree_of, lambda { |object| {:conditions => to_node(object).subtree_conditions} }
-    send scope_method, :siblings_of, lambda { |object| {:conditions => to_node(object).sibling_conditions} }
-    send scope_method, :ordered_by_ancestry, :order => "(case when #{table_name}.#{ancestry_column} is null then 0 else 1 end), #{table_name}.#{ancestry_column}"
-    send scope_method, :ordered_by_ancestry_and, lambda { |order| {:order => "(case when #{table_name}.#{ancestry_column} is null then 0 else 1 end), #{table_name}.#{ancestry_column}, #{order}"} }
+    scope :roots, lambda { where(ancestry_column => nil) }
+    scope :ancestors_of, lambda { |object| where(to_node(object).ancestor_conditions) }
+    scope :children_of, lambda { |object| where(to_node(object).child_conditions) }
+    scope :descendants_of, lambda { |object| where(to_node(object).descendant_conditions) }
+    scope :subtree_of, lambda { |object| where(to_node(object).subtree_conditions) }
+    scope :siblings_of, lambda { |object| where(to_node(object).sibling_conditions) }
+    scope :ordered_by_ancestry, lambda { reorder("(case when #{table_name}.#{ancestry_column} is null then 0 else 1 end), #{table_name}.#{ancestry_column}") }
+    scope :ordered_by_ancestry_and, lambda { |order| reorder("(case when #{table_name}.#{ancestry_column} is null then 0 else 1 end), #{table_name}.#{ancestry_column}, #{order}") }
     
     # Update descendants with new ancestry before save
     before_save :update_descendants_with_new_ancestry
@@ -64,6 +56,7 @@ class << ActiveRecord::Base
 
       # Cache depth in depth cache column before save
       before_validation :cache_depth
+      before_save :cache_depth
 
       # Validate depth column
       validates_numericality_of depth_cache_column, :greater_than_or_equal_to => 0, :only_integer => true, :allow_nil => false
@@ -71,9 +64,9 @@ class << ActiveRecord::Base
     
     # Create named scopes for depth
     {:before_depth => '<', :to_depth => '<=', :at_depth => '=', :from_depth => '>=', :after_depth => '>'}.each do |scope_name, operator|
-      send scope_method, scope_name, lambda { |depth|
+      scope scope_name, lambda { |depth|
         raise Ancestry::AncestryException.new("Named scope '#{scope_name}' is only available when depth caching is enabled.") unless options[:cache_depth]
-        {:conditions => ["#{depth_cache_column} #{operator} ?", depth]}
+        where("#{depth_cache_column} #{operator} ?", depth)
       }
     end
   end

data/lib/ancestry/instance_methods.rb

@@ -2,21 +2,21 @@ module Ancestry
   module InstanceMethods
     # Validate that the ancestors don't include itself
     def ancestry_exclude_self
-      add_error_to_base "#{self.class.name.humanize} cannot be a descendant of itself." if ancestor_ids.include? self.id
+      errors.add(:base, "#{self.class.name.humanize} cannot be a descendant of itself.") if ancestor_ids.include? self.id
     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_column.to_s) && !new_record? && valid?
+        # If node is not a new record and ancestry was updated and the new ancestry is sane ...
+        if ancestry_changed? && !new_record? && sane_ancestry?
           # ... for each descendant ...
           unscoped_descendants.each do |descendant|
             # ... replace old ancestry with new ancestry
             descendant.without_ancestry_callbacks do
               descendant.update_attribute(
-                self.base_class.ancestry_column,
+                self.ancestry_base_class.ancestry_column,
                 descendant.read_attribute(descendant.class.ancestry_column).gsub(
                   /^#{self.child_ancestry}/,
                   if read_attribute(self.class.ancestry_column).blank? then id.to_s else "#{read_attribute self.class.ancestry_column }/#{id}" end
@@ -35,21 +35,29 @@ module Ancestry
         # If this isn't a new record ...
         unless new_record?
           # ... make all children root if orphan strategy is rootify
-          if self.base_class.orphan_strategy == :rootify
+          if self.ancestry_base_class.orphan_strategy == :rootify
             unscoped_descendants.each do |descendant|
               descendant.without_ancestry_callbacks do
                 descendant.update_attribute descendant.class.ancestry_column, (if descendant.ancestry == child_ancestry then nil else descendant.ancestry.gsub(/^#{child_ancestry}\//, '') end)
               end
             end
           # ... destroy all descendants if orphan strategy is destroy
-          elsif self.base_class.orphan_strategy == :destroy
+          elsif self.ancestry_base_class.orphan_strategy == :destroy
             unscoped_descendants.each do |descendant|
               descendant.without_ancestry_callbacks do
                 descendant.destroy
               end
             end
+          # ... make child elements of this node, child of its parent if orphan strategy is adopt
+          elsif self.ancestry_base_class.orphan_strategy == :adopt
+            descendants.each do |descendant|
+              descendant.without_ancestry_callbacks do
+                new_ancestry = descendant.ancestor_ids.delete_if { |x| x == self.id }.join("/")
+                descendant.update_attribute descendant.class.ancestry_column, new_ancestry || nil
+              end
+            end
           # ... throw an exception if it has children and orphan strategy is restrict
-          elsif self.base_class.orphan_strategy == :restrict
+          elsif self.ancestry_base_class.orphan_strategy == :restrict
             raise Ancestry::AncestryException.new('Cannot delete record because it has descendants.') unless is_childless?
           end
         end
@@ -61,20 +69,24 @@ module Ancestry
       # New records cannot have children
       raise Ancestry::AncestryException.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
 
-      if self.send("#{self.base_class.ancestry_column}_was").blank? then id.to_s else "#{self.send "#{self.base_class.ancestry_column}_was"}/#{id}" end
+      if self.send("#{self.ancestry_base_class.ancestry_column}_was").blank? then id.to_s else "#{self.send "#{self.ancestry_base_class.ancestry_column}_was"}/#{id}" end
     end
 
     # Ancestors
+    def ancestry_changed?
+      changed.include?(self.ancestry_base_class.ancestry_column.to_s)
+    end
+
     def ancestor_ids
-      read_attribute(self.base_class.ancestry_column).to_s.split('/').map { |id| cast_primary_key(id) }
+      read_attribute(self.ancestry_base_class.ancestry_column).to_s.split('/').map { |id| cast_primary_key(id) }
     end
 
     def ancestor_conditions
-      {self.base_class.primary_key => ancestor_ids}
+      {primary_key_with_table => ancestor_ids}
     end
 
     def ancestors depth_options = {}
-      self.base_class.scope_depth(depth_options, depth).ordered_by_ancestry.scoped :conditions => ancestor_conditions
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where  ancestor_conditions
     end
 
     def path_ids
@@ -82,11 +94,11 @@ module Ancestry
     end
 
     def path_conditions
-      {self.base_class.primary_key => path_ids}
+      {primary_key_with_table => path_ids}
     end
 
     def path depth_options = {}
-      self.base_class.scope_depth(depth_options, depth).ordered_by_ancestry.scoped :conditions => path_conditions
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where  path_conditions
     end
 
     def depth
@@ -94,16 +106,16 @@ module Ancestry
     end
 
     def cache_depth
-      write_attribute self.base_class.depth_cache_column, depth
+      write_attribute self.ancestry_base_class.depth_cache_column, depth
     end
 
     # Parent
     def parent= parent
-      write_attribute(self.base_class.ancestry_column, if parent.blank? then nil else parent.child_ancestry end)
+      write_attribute(self.ancestry_base_class.ancestry_column, if parent.nil? then nil else parent.child_ancestry end)
     end
 
     def parent_id= parent_id
-      self.parent = if parent_id.blank? then nil else self.base_class.find(parent_id) end
+      self.parent = if parent_id.blank? then nil else unscoped_find(parent_id) end
     end
 
     def parent_id
@@ -111,7 +123,11 @@ module Ancestry
     end
 
     def parent
-      if parent_id.blank? then nil else self.base_class.find(parent_id) end
+      if parent_id.blank? then nil else unscoped_find(parent_id) end
+    end
+
+    def parent_id?
+      parent_id.present?
     end
 
     # Root
@@ -120,24 +136,25 @@ module Ancestry
     end
 
     def root
-      if root_id == id then self else self.base_class.find(root_id) end
+      if root_id == id then self else unscoped_find(root_id) end
     end
 
     def is_root?
-      read_attribute(self.base_class.ancestry_column).blank?
+      read_attribute(self.ancestry_base_class.ancestry_column).blank?
     end
+    alias :root? :is_root?
 
     # Children
     def child_conditions
-      {self.base_class.ancestry_column => child_ancestry}
+      {ancestry_column_with_table => child_ancestry}
     end
 
     def children
-      self.base_class.scoped :conditions => child_conditions
+      self.ancestry_base_class.where child_conditions
     end
 
     def child_ids
-      children.all(:select => self.base_class.primary_key).map(&self.base_class.primary_key.to_sym)
+      children.select(self.ancestry_base_class.primary_key).map(&self.ancestry_base_class.primary_key.to_sym)
     end
 
     def has_children?
@@ -150,15 +167,15 @@ module Ancestry
 
     # Siblings
     def sibling_conditions
-      {self.base_class.ancestry_column => read_attribute(self.base_class.ancestry_column)}
+      {ancestry_column_with_table => read_attribute(self.ancestry_base_class.ancestry_column)}
     end
 
     def siblings
-      self.base_class.scoped :conditions => sibling_conditions
+      self.ancestry_base_class.where sibling_conditions
     end
 
     def sibling_ids
-       siblings.all(:select => self.base_class.primary_key).collect(&self.base_class.primary_key.to_sym)
+      siblings.select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
     end
 
     def has_siblings?
@@ -171,28 +188,28 @@ module Ancestry
 
     # Descendants
     def descendant_conditions
-      ["#{self.base_class.table_name}.#{self.base_class.ancestry_column} like ? or #{self.base_class.table_name}.#{self.base_class.ancestry_column} = ?", "#{child_ancestry}/%", child_ancestry]
+      ["#{ancestry_column_with_table} like ? or #{ancestry_column_with_table} = ?", "#{child_ancestry}/%", child_ancestry]
     end
 
     def descendants depth_options = {}
-      self.base_class.ordered_by_ancestry.scope_depth(depth_options, depth).scoped :conditions => descendant_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where descendant_conditions
     end
 
     def descendant_ids depth_options = {}
-      descendants(depth_options).all(:select => self.base_class.primary_key).collect(&self.base_class.primary_key.to_sym)
+      descendants(depth_options).select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
     end
 
     # Subtree
     def subtree_conditions
-      ["#{self.base_class.table_name}.#{self.base_class.primary_key} = ? or #{self.base_class.table_name}.#{self.base_class.ancestry_column} like ? or #{self.base_class.table_name}.#{self.base_class.ancestry_column} = ?", self.id, "#{child_ancestry}/%", child_ancestry]
+      ["#{primary_key_with_table} = ? or #{ancestry_column_with_table} like ? or #{ancestry_column_with_table} = ?", self.id, "#{child_ancestry}/%", child_ancestry]
     end
 
     def subtree depth_options = {}
-      self.base_class.ordered_by_ancestry.scope_depth(depth_options, depth).scoped :conditions => subtree_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where subtree_conditions
     end
 
     def subtree_ids depth_options = {}
-      subtree(depth_options).all(:select => self.base_class.primary_key).collect(&self.base_class.primary_key.to_sym)
+      subtree(depth_options).select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
     end
 
     # Callback disabling
@@ -208,15 +225,6 @@ module Ancestry
 
   private
 
-    # Workaround to support Rails 2
-    def add_error_to_base error
-      if rails_3
-        errors[:base] << error
-      else
-        errors.add_to_base error
-      end
-    end
-
     def cast_primary_key(key)
       if primary_key_type == :string
         key
@@ -228,11 +236,28 @@ module Ancestry
     def primary_key_type
       @primary_key_type ||= column_for_attribute(self.class.primary_key).type
     end
-    
     def unscoped_descendants
-      self.base_class.send(:with_exclusive_scope) do 
-        self.base_class.all(:conditions => descendant_conditions) 
+      self.ancestry_base_class.unscoped do
+        self.ancestry_base_class.where descendant_conditions
       end
     end
+
+    # basically validates the ancestry, but also applied if validation is
+    # bypassed to determine if chidren should be affected
+    def sane_ancestry?
+      ancestry.nil? || (ancestry.to_s =~ Ancestry::ANCESTRY_PATTERN && !ancestor_ids.include?(self.id))
+    end
+
+    def unscoped_find id
+      self.ancestry_base_class.unscoped { self.ancestry_base_class.find(id) }
+    end
+
+    def primary_key_with_table
+      "#{self.ancestry_base_class.table_name}.#{self.ancestry_base_class.primary_key}"
+    end
+
+    def ancestry_column_with_table
+      "#{self.ancestry_base_class.table_name}.#{self.ancestry_base_class.ancestry_column}"
+    end
   end
 end

metadata

@@ -1,46 +1,38 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ancestry
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 3
-  - 0
-  version: 1.3.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0.rc1
+  prerelease: 6
 platform: ruby
-authors: 
+authors:
 - Stefan Kroes
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-05-04 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        - 14
-        version: 2.3.14
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: Organise ActiveRecord model into a tree structure
 email: s.a.kroes@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - ancestry.gemspec
 - init.rb
 - install.rb
@@ -51,37 +43,34 @@ files:
 - lib/ancestry/instance_methods.rb
 - MIT-LICENSE
 - README.rdoc
-has_rdoc: true
 homepage: http://github.com/stefankroes/ancestry
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.
+summary: Ancestry allows the records of a ActiveRecord model to be organised in a
+  tree structure, using a single, intuitively formatted database column. It exposes
+  all the standard tree structure relations (ancestors, parent, root, children, siblings,
+  descendants) and all of them can be fetched in a single sql query. Additional features
+  are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree
+  into hashes and different strategies for dealing with orphaned records.
 test_files: []
-
+has_rdoc: