ancestry 3.0.5 → 3.2.1

data/lib/ancestry.rb

@@ -4,7 +4,34 @@ require_relative 'ancestry/instance_methods'
 require_relative 'ancestry/exceptions'
 require_relative 'ancestry/has_ancestry'
 require_relative 'ancestry/materialized_path'
+require_relative 'ancestry/materialized_path_pg'
+
+I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)),
+                                 'ancestry', 'locales', '*.{rb,yml}').to_s]
 
 module Ancestry
-  ANCESTRY_PATTERN = /\A[0-9]+(\/[0-9]+)*\Z/
+  @@default_update_strategy = :ruby
+
+  # @!default_update_strategy
+  #   @return [Symbol] the default strategy for updating ancestry
+  #
+  # The value changes the default way that ancestry is updated for associated records
+  #
+  #    :ruby (default and legacy value)
+  #
+  #        Child records will be loaded into memory and updated. callbacks will get called
+  #        The callbacks of interest are those that cache values based upon the ancestry value
+  #
+  #    :sql (currently only valid in postgres)
+  #
+  #        Child records are updated in sql and callbacks will not get called.
+  #        Associated records in memory will have the wrong ancestry value
+
+  def self.default_update_strategy
+    @@default_update_strategy
+  end
+
+  def self.default_update_strategy=(value)
+    @@default_update_strategy = value
+  end
 end

data/lib/ancestry/class_methods.rb

@@ -2,7 +2,11 @@ module Ancestry
   module ClassMethods
     # Fetch tree node if necessary
     def to_node object
-      if object.is_a?(self.ancestry_base_class) then object else unscoped_where{|scope| scope.find object} end
+      if object.is_a?(self.ancestry_base_class)
+        object
+      else
+        unscoped_where { |scope| scope.find(object.try(primary_key) || object) }
+      end
     end
 
     # Scope on relative depth options
@@ -12,7 +16,7 @@ module Ancestry
         if [:before_depth, :to_depth, :at_depth, :from_depth, :after_depth].include? scope_name
           scope.send scope_name, depth + relative_depth
         else
-          raise Ancestry::AncestryException.new("Unknown depth option: #{scope_name}.")
+          raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_depth_option", {:scope_name => scope_name}))
         end
       end
     end
@@ -23,11 +27,17 @@ module Ancestry
       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,:adopt, :restrict and :destroy.")
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.invalid_orphan_strategy"))
       end
     end
 
-    # Get all nodes and sorting them into an empty hash
+
+    # these methods arrange an entire subtree into nested hashes for easy navigation after database retrieval
+    # the arrange method also works on a scoped class
+    # the arrange method takes ActiveRecord find options
+    # To order your hashes pass the order to the arrange method instead of to the scope
+
+    # Get all nodes and sort them into an empty hash
     def arrange options = {}
       if (order = options.delete(:order))
         arrange_nodes self.ancestry_base_class.order(order).where(options)
@@ -50,7 +60,9 @@ module Ancestry
       end
     end
 
-     # Arrangement to nested array
+     # Arrangement to nested array for serialization
+     # You can also supply your own serialization logic using blocks
+     # also allows you to pass the order just as you can pass it to the arrange method
     def arrange_serializable options={}, nodes=nil, &block
       nodes = arrange(options) if nodes.nil?
       nodes.map do |parent, children|
@@ -63,7 +75,6 @@ module Ancestry
     end
 
     # Pseudo-preordered array of nodes.  Children will always follow parents,
-    # 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)
 
@@ -90,6 +101,9 @@ module Ancestry
     end
 
     # Integrity checking
+    # compromised tree integrity is unlikely without explicitly setting cyclic parents or invalid ancestry and circumventing validation
+    # just in case, raise an AncestryIntegrityException if issues are detected
+    # specify :report => :list to return an array of exceptions or :report => :echo to echo any error messages
     def check_ancestry_integrity! options = {}
       parents = {}
       exceptions = [] if options[:report] == :list
@@ -99,20 +113,30 @@ module Ancestry
         scope.find_each do |node|
           begin
             # ... check validity of ancestry column
-            if !node.valid? and !node.errors[node.class.ancestry_column].blank?
-              raise Ancestry::AncestryIntegrityException.new("Invalid format for ancestry column of node #{node.id}: #{node.read_attribute node.ancestry_column}.")
+            if !node.sane_ancestor_ids?
+              raise Ancestry::AncestryIntegrityException.new(I18n.t("ancestry.invalid_ancestry_column",
+                                                                    :node_id => node.id,
+                                                                    :ancestry_column => "#{node.read_attribute node.ancestry_column}"
+                                                                    ))
             end
             # ... check that all ancestors exist
             node.ancestor_ids.each do |ancestor_id|
               unless exists? ancestor_id
-                raise Ancestry::AncestryIntegrityException.new("Reference to non-existent node in node #{node.id}: #{ancestor_id}.")
+                raise Ancestry::AncestryIntegrityException.new(I18n.t("ancestry.reference_nonexistent_node",
+                                                                      :node_id => node.id,
+                                                                      :ancestor_id => ancestor_id
+                                                                      ))
               end
             end
             # ... check that all node parents are consistent with values observed earlier
             node.path_ids.zip([nil] + node.path_ids).each do |node_id, parent_id|
               parents[node_id] = parent_id unless parents.has_key? node_id
               unless parents[node_id] == parent_id
-                raise Ancestry::AncestryIntegrityException.new("Conflicting parent id found in node #{node.id}: #{parent_id || 'nil'} for node #{node_id} while expecting #{parents[node_id] || 'nil'}")
+                raise Ancestry::AncestryIntegrityException.new(I18n.t("ancestry.conflicting_parent_id",
+                                                                      :node_id => node_id,
+                                                                      :parent_id => parent_id || 'nil',
+                                                                      :expected => parents[node_id] || 'nil'
+                                                                      ))
               end
             end
           rescue Ancestry::AncestryIntegrityException => integrity_exception
@@ -129,59 +153,59 @@ module Ancestry
 
     # Integrity restoration
     def restore_ancestry_integrity!
-      parents = {}
+      parent_ids = {}
       # Wrap the whole thing in a transaction ...
       self.ancestry_base_class.transaction do
         unscoped_where do |scope|
           # For each node ...
           scope.find_each do |node|
             # ... set its ancestry to nil if invalid
-            if !node.valid? and !node.errors[node.class.ancestry_column].blank?
+            if !node.sane_ancestor_ids?
               node.without_ancestry_callbacks do
-                node.update_attribute node.ancestry_column, nil
+                node.update_attribute :ancestor_ids, []
               end
             end
-            # ... save parent of this node in parents array if it exists
-            parents[node.id] = node.parent_id if exists? node.parent_id
+            # ... save parent id of this node in parent_ids array if it exists
+            parent_ids[node.id] = node.parent_id if exists? node.parent_id
 
             # Reset parent id in array to nil if it introduces a cycle
-            parent = parents[node.id]
-            until parent.nil? || parent == node.id
-              parent = parents[parent]
+            parent_id = parent_ids[node.id]
+            until parent_id.nil? || parent_id == node.id
+              parent_id = parent_ids[parent_id]
             end
-            parents[node.id] = nil if parent == node.id
+            parent_ids[node.id] = nil if parent_id == node.id
           end
 
           # For each node ...
           scope.find_each do |node|
-            # ... rebuild ancestry from parents array
-            ancestry, parent = nil, parents[node.id]
-            until parent.nil?
-              ancestry, parent = if ancestry.nil? then parent else "#{parent}/#{ancestry}" end, parents[parent]
+            # ... rebuild ancestry from parent_ids array
+            ancestor_ids, parent_id = [], parent_ids[node.id]
+            until parent_id.nil?
+              ancestor_ids, parent_id = [parent_id] + ancestor_ids, parent_ids[parent_id]
             end
             node.without_ancestry_callbacks do
-              node.update_attribute node.ancestry_column, ancestry
+              node.update_attribute :ancestor_ids, ancestor_ids
             end
           end
         end
       end
     end
 
-    # Build ancestry from parent id's for migration purposes
-    def build_ancestry_from_parent_ids! parent_id = nil, ancestry = nil
+    # Build ancestry from parent ids for migration purposes
+    def build_ancestry_from_parent_ids! column=:parent_id, parent_id = nil, ancestor_ids = []
       unscoped_where do |scope|
-        scope.where(:parent_id => parent_id).find_each do |node|
+        scope.where(column => parent_id).find_each do |node|
           node.without_ancestry_callbacks do
-            node.update_attribute ancestry_column, ancestry
+            node.update_attribute :ancestor_ids, ancestor_ids
           end
-          build_ancestry_from_parent_ids! node.id, if ancestry.nil? then "#{node.id}" else "#{ancestry}/#{node.id}" end
+          build_ancestry_from_parent_ids! column, node.id, ancestor_ids + [node.id]
         end
       end
     end
 
     # Rebuild depth cache if it got corrupted or if depth caching was just turned on
     def rebuild_depth_cache!
-      raise Ancestry::AncestryException.new("Cannot rebuild depth cache for model without depth caching.") unless respond_to? :depth_cache_column
+      raise Ancestry::AncestryException.new(I18n.t("ancestry.cannot_rebuild_depth_cache")) unless respond_to? :depth_cache_column
 
       self.ancestry_base_class.transaction do
         unscoped_where do |scope|
@@ -203,7 +227,7 @@ module Ancestry
     end
 
     ANCESTRY_UNCAST_TYPES = [:string, :uuid, :text].freeze
-    if ActiveSupport::VERSION::STRING < "4.0"
+    if ActiveSupport::VERSION::STRING < "4.2"
       def primary_key_is_an_integer?
         if defined?(@primary_key_is_an_integer)
           @primary_key_is_an_integer

data/lib/ancestry/has_ancestry.rb

@@ -2,14 +2,13 @@ module Ancestry
   module HasAncestry
     def has_ancestry options = {}
       # Check options
-      raise Ancestry::AncestryException.new("Options for has_ancestry must be in a hash.") unless options.is_a? Hash
+      raise Ancestry::AncestryException.new(I18n.t("ancestry.option_must_be_hash")) unless options.is_a? Hash
       options.each do |key, value|
-        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch].include? key
-          raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
+        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format, :update_strategy].include? key
+          raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_option", {:key => key.inspect, :value => value.inspect}))
         end
       end
 
-
       # Create ancestry column accessor and set to option or default
       cattr_accessor :ancestry_column
       self.ancestry_column = options[:ancestry_column] || :ancestry
@@ -28,8 +27,12 @@ module Ancestry
       # Include dynamic class methods
       extend Ancestry::ClassMethods
 
+      validates_format_of self.ancestry_column, :with => derive_ancestry_pattern(options[:primary_key_format]), :allow_nil => true
       extend Ancestry::MaterializedPath
 
+      update_strategy = options[:update_strategy] || Ancestry.default_update_strategy
+      include Ancestry::MaterializedPathPg if update_strategy == :sql
+
       # Create orphan strategy accessor and set to option or default (writer comes from DynamicClassMethods)
       cattr_reader :orphan_strategy
       self.orphan_strategy = options[:orphan_strategy] || :destroy
@@ -37,27 +40,6 @@ module Ancestry
       # Validate that the ancestor ids don't include own id
       validate :ancestry_exclude_self
 
-      # Named scopes
-      scope :roots, lambda { where(root_conditions) }
-      scope :ancestors_of, lambda { |object| where(ancestor_conditions(object)) }
-      scope :children_of, lambda { |object| where(child_conditions(object)) }
-      scope :indirects_of, lambda { |object| where(indirect_conditions(object)) }
-      scope :descendants_of, lambda { |object| where(descendant_conditions(object)) }
-      scope :subtree_of, lambda { |object| where(subtree_conditions(object)) }
-      scope :siblings_of, lambda { |object| where(sibling_conditions(object)) }
-      scope :ordered_by_ancestry, Proc.new { |order|
-        if %w(mysql mysql2 sqlite sqlite3 postgresql).include?(connection.adapter_name.downcase) && ActiveRecord::VERSION::MAJOR >= 5
-          reorder(
-            Arel::Nodes::Ascending.new(Arel::Nodes::NamedFunction.new('COALESCE', [arel_table[ancestry_column], Arel.sql("''")])),
-            order
-          )
-        else
-          reorder(Arel.sql("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}"), order)
-        end
-      }
-      scope :ordered_by_ancestry_and, Proc.new { |order| ordered_by_ancestry(order) }
-      scope :path_of, lambda { |object| to_node(object).path }
-
       # Update descendants with new ancestry before save
       before_save :update_descendants_with_new_ancestry
 
@@ -78,10 +60,27 @@ module Ancestry
         validates_numericality_of depth_cache_column, :greater_than_or_equal_to => 0, :only_integer => true, :allow_nil => false
       end
 
+      # Create counter cache column accessor and set to option or default
+      if options[:counter_cache]
+        cattr_accessor :counter_cache_column
+
+        if options[:counter_cache] == true
+          self.counter_cache_column = :children_count
+        else
+          self.counter_cache_column = options[:counter_cache]
+        end
+
+        after_create :increase_parent_counter_cache, if: :has_parent?
+        after_destroy :decrease_parent_counter_cache, if: :has_parent?
+        after_update :update_parent_counter_cache
+      end
+
       # Create named scopes for depth
       {:before_depth => '<', :to_depth => '<=', :at_depth => '=', :from_depth => '>=', :after_depth => '>'}.each do |scope_name, operator|
         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]
+          raise Ancestry::AncestryException.new(I18n.t("ancestry.named_scope_depth_cache",
+                                                       :scope_name => scope_name
+                                                       )) unless options[:cache_depth]
           where("#{depth_cache_column} #{operator} ?", depth)
         }
       end
@@ -100,6 +99,18 @@ module Ancestry
       return super if defined?(super)
       has_ancestry(*args)
     end
+
+    private
+
+    def derive_ancestry_pattern(primary_key_format, delimiter = '/')
+      primary_key_format ||= '[0-9]+'
+
+      if primary_key_format.to_s.include?('\A')
+        primary_key_format
+      else
+        /\A#{primary_key_format}(#{delimiter}#{primary_key_format})*\Z/
+      end
+    end
   end
 end
 

data/lib/ancestry/instance_methods.rb

@@ -1,11 +1,8 @@
 module Ancestry
   module InstanceMethods
-    BEFORE_LAST_SAVE_SUFFIX = ActiveRecord::VERSION::STRING >= '5.1.0' ? '_before_last_save' : '_was'
-    IN_DATABASE_SUFFIX = ActiveRecord::VERSION::STRING >= '5.1.0' ? '_in_database' : '_was'
-
     # Validate that the ancestors don't include itself
     def ancestry_exclude_self
-      errors.add(:base, "#{self.class.name.humanize} cannot be a descendant of itself.") if ancestor_ids.include? self.id
+      errors.add(:base, I18n.t("ancestry.exclude_self", {:class_name => self.class.name.humanize})) if ancestor_ids.include? self.id
     end
 
     # Update descendants with new ancestry (before save)
@@ -16,15 +13,8 @@ module Ancestry
         unscoped_descendants.each do |descendant|
           # ... replace old ancestry with new ancestry
           descendant.without_ancestry_callbacks do
-            descendant.update_attribute(
-              self.ancestry_base_class.ancestry_column,
-              descendant.read_attribute(descendant.class.ancestry_column).gsub(
-                # child_ancestry_was
-                /^#{self.child_ancestry}/,
-                # future child_ancestry
-                if ancestors? then "#{read_attribute self.class.ancestry_column }/#{id}" else id.to_s end
-              )
-            )
+            new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_in_database)
+            descendant.update_attribute(:ancestor_ids, new_ancestor_ids)
           end
         end
       end
@@ -37,13 +27,7 @@ module Ancestry
         when :rootify # make all children root if orphan strategy is rootify
           unscoped_descendants.each do |descendant|
             descendant.without_ancestry_callbacks do
-              new_ancestry = if descendant.ancestry == child_ancestry
-                nil
-              else
-                # child_ancestry did not change so child_ancestry_was will work here
-                descendant.ancestry.gsub(/^#{child_ancestry}\//, '')
-              end
-              descendant.update_attribute descendant.class.ancestry_column, new_ancestry
+              descendant.update_attribute :ancestor_ids, descendant.ancestor_ids - path_ids
             end
           end
         when :destroy # destroy all descendants if orphan strategy is destroy
@@ -55,14 +39,11 @@ module Ancestry
         when :adopt # make child elements of this node, child of its parent
           descendants.each do |descendant|
             descendant.without_ancestry_callbacks do
-              new_ancestry = descendant.ancestor_ids.delete_if { |x| x == self.id }.join("/")
-              # check for empty string if it's then set to nil
-              new_ancestry = nil if new_ancestry.empty?
-              descendant.update_attribute descendant.class.ancestry_column, new_ancestry || nil
+              descendant.update_attribute :ancestor_ids, descendant.ancestor_ids.delete_if { |x| x == self.id }
             end
           end
         when :restrict # throw an exception if it has children
-          raise Ancestry::AncestryException.new('Cannot delete record because it has descendants.') unless is_childless?
+          raise Ancestry::AncestryException.new(I18n.t("ancestry.cannot_delete_descendants")) unless is_childless?
         end
       end
     end
@@ -79,67 +60,81 @@ module Ancestry
       end
     end
 
-    # The ancestry value for this record's children (before save)
-    # This is technically child_ancestry_was
-    def child_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.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}").blank?
-        id.to_s
-      else
-        "#{self.send "#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}"}/#{id}"
-      end
+    # Counter Cache
+    def increase_parent_counter_cache
+      self.class.increment_counter _counter_cache_column, parent_id
     end
 
-    # Ancestors
+    def decrease_parent_counter_cache
+      # @_trigger_destroy_callback comes from activerecord, which makes sure only once decrement when concurrent deletion.
+      # but @_trigger_destroy_callback began after rails@5.1.0.alpha.
+      # https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/persistence.rb#L340
+      # https://github.com/rails/rails/pull/14735
+      # https://github.com/rails/rails/pull/27248
+      return if defined?(@_trigger_destroy_callback) && !@_trigger_destroy_callback
+      return if ancestry_callbacks_disabled?
 
-    def ancestors?
-      # ancestor_ids.present?
-      read_attribute(self.ancestry_base_class.ancestry_column).present?
+      self.class.decrement_counter _counter_cache_column, parent_id
     end
-    alias :has_parent? :ancestors?
 
-    def ancestry_changed?
-      changed.include?(self.ancestry_base_class.ancestry_column.to_s)
-    end
+    def update_parent_counter_cache
+      changed =
+        if ActiveRecord::VERSION::STRING >= '5.1.0'
+          saved_change_to_attribute?(self.ancestry_base_class.ancestry_column)
+        else
+          ancestry_changed?
+        end
 
-    def ancestor_ids
-      parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
+      return unless changed
+
+      if parent_id_was = parent_id_before_last_save
+        self.class.decrement_counter _counter_cache_column, parent_id_was
+      end
+
+      parent_id && self.class.increment_counter(_counter_cache_column, parent_id)
     end
 
-    def ancestor_conditions
-      self.ancestry_base_class.ancestor_conditions(self)
+    def _counter_cache_column
+      self.ancestry_base_class.counter_cache_column.to_s
     end
 
-    def ancestors depth_options = {}
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where ancestor_conditions
+    # Ancestors
+
+    def ancestors?
+      ancestor_ids.present?
     end
+    alias :has_parent? :ancestors?
 
-    # deprecate
-    def ancestor_was_conditions
-      {primary_key_with_table => ancestor_ids_before_last_save}
+    def ancestry_changed?
+      column = self.ancestry_base_class.ancestry_column.to_s
+      if ActiveRecord::VERSION::STRING >= '5.1.0'
+        # These methods return nil if there are no changes.
+        # This was fixed in a refactoring in rails 6.0: https://github.com/rails/rails/pull/35933
+        !!(will_save_change_to_attribute?(column) || saved_change_to_attribute?(column))
+      else
+        changed.include?(column)
+      end
     end
 
-    # deprecated - probably don't want to use anymore
-    def ancestor_ids_was
-      parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}_was"))
+    def sane_ancestor_ids?
+      valid? || errors[self.ancestry_base_class.ancestry_column].blank?
     end
 
-    def ancestor_ids_before_last_save
-      parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}"))
+    def ancestors depth_options = {}
+      return self.ancestry_base_class.none unless ancestors?
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.ancestors_of(self)
     end
 
     def path_ids
       ancestor_ids + [id]
     end
 
-    def path_conditions
-      self.ancestry_base_class.path_conditions(self)
+    def path_ids_in_database
+      ancestor_ids_in_database + [id]
     end
 
     def path depth_options = {}
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where path_conditions
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.inpath_of(self)
     end
 
     def depth
@@ -159,7 +154,7 @@ module Ancestry
     # currently parent= does not work in after save callbacks
     # assuming that parent hasn't changed
     def parent= parent
-      write_attribute(self.ancestry_base_class.ancestry_column, if parent.nil? then nil else parent.child_ancestry end)
+      self.ancestor_ids = parent ? parent.path_ids : []
     end
 
     def parent_id= new_parent_id
@@ -169,15 +164,12 @@ module Ancestry
     def parent_id
       ancestor_ids.last if ancestors?
     end
+    alias :parent_id? :ancestors?
 
     def parent
       unscoped_find(parent_id) if ancestors?
     end
 
-    def parent_id?
-      ancestors?
-    end
-
     def parent_of?(node)
       self.id == node.parent_id
     end
@@ -193,7 +185,7 @@ module Ancestry
     end
 
     def is_root?
-      read_attribute(self.ancestry_base_class.ancestry_column).blank?
+      !ancestors?
     end
     alias :root? :is_root?
 
@@ -203,12 +195,8 @@ module Ancestry
 
     # Children
 
-    def child_conditions
-      self.ancestry_base_class.child_conditions(self)
-    end
-
     def children
-      self.ancestry_base_class.where child_conditions
+      self.ancestry_base_class.children_of(self)
     end
 
     def child_ids
@@ -231,14 +219,11 @@ module Ancestry
 
     # Siblings
 
-    def sibling_conditions
-      self.ancestry_base_class.sibling_conditions(self)
-    end
-
     def siblings
-      self.ancestry_base_class.where sibling_conditions
+      self.ancestry_base_class.siblings_of(self)
     end
 
+    # NOTE: includes self
     def sibling_ids
       siblings.pluck(self.ancestry_base_class.primary_key)
     end
@@ -254,17 +239,13 @@ module Ancestry
     alias_method :only_child?, :is_only_child?
 
     def sibling_of?(node)
-      self.ancestry == node.ancestry
+      self.ancestor_ids == node.ancestor_ids
     end
 
     # Descendants
 
-    def descendant_conditions
-      self.ancestry_base_class.descendant_conditions(self)
-    end
-
     def descendants depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where descendant_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).descendants_of(self)
     end
 
     def descendant_ids depth_options = {}
@@ -277,12 +258,8 @@ module Ancestry
 
     # Indirects
 
-    def indirect_conditions
-      self.ancestry_base_class.indirect_conditions(self)
-    end
-
     def indirects depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where indirect_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).indirects_of(self)
     end
 
     def indirect_ids depth_options = {}
@@ -295,12 +272,8 @@ module Ancestry
 
     # Subtree
 
-    def subtree_conditions
-      self.ancestry_base_class.subtree_conditions(self)
-    end
-
     def subtree depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where subtree_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).subtree_of(self)
     end
 
     def subtree_ids depth_options = {}
@@ -320,17 +293,9 @@ module Ancestry
     end
 
   private
-    ANCESTRY_DELIMITER = '/'.freeze
-
-    def parse_ancestry_column obj
-      return [] unless obj
-      obj_ids = obj.split(ANCESTRY_DELIMITER)
-      self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
-    end
-
     def unscoped_descendants
       unscoped_where do |scope|
-        scope.where descendant_conditions
+        scope.where self.ancestry_base_class.descendant_conditions(self)
       end
     end