ancestry 4.3.3 → 5.1.0

data/lib/ancestry/has_ancestry.rb

@@ -1,33 +1,40 @@
+# frozen_string_literal: true
+
 module Ancestry
   module HasAncestry
-    def has_ancestry options = {}
+    def has_ancestry(options = {})
       # Check options
-      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, :counter_cache, :primary_key_format, :update_strategy, :ancestry_format].include? key
-          raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_option", key: key.inspect, value: value.inspect))
-        end
+      unless options.is_a? Hash
+        raise Ancestry::AncestryException, I18n.t("ancestry.option_must_be_hash")
+      end
+
+      extra_keys = options.keys - [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format, :update_strategy, :ancestry_format]
+      if (key = extra_keys.first)
+        raise Ancestry::AncestryException, I18n.t("ancestry.unknown_option", key: key.inspect, value: options[key].inspect)
       end
 
-      if options[:ancestry_format].present? && ![:materialized_path, :materialized_path2].include?( options[:ancestry_format] )
-        raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_format", value: options[:ancestry_format]))
+      ancestry_format = options[:ancestry_format] || Ancestry.default_ancestry_format
+      if ![:materialized_path, :materialized_path2].include?(ancestry_format)
+        raise Ancestry::AncestryException, I18n.t("ancestry.unknown_format", value: ancestry_format)
       end
 
+      orphan_strategy = options[:orphan_strategy] || :destroy
+
       # Create ancestry column accessor and set to option or default
-      cattr_accessor :ancestry_column
-      self.ancestry_column = options[:ancestry_column] || :ancestry
+      class_variable_set('@@ancestry_column', options[:ancestry_column] || :ancestry)
+      cattr_reader :ancestry_column, instance_reader: false
 
-      cattr_accessor :ancestry_primary_key_format
-      self.ancestry_primary_key_format = options[:primary_key_format].presence || Ancestry.default_primary_key_format
+      primary_key_format = options[:primary_key_format].presence || Ancestry.default_primary_key_format
 
-      cattr_accessor :ancestry_delimiter
-      self.ancestry_delimiter = '/'
+      class_variable_set('@@ancestry_delimiter', '/')
+      cattr_reader :ancestry_delimiter, instance_reader: false
 
       # Save self as base class (for STI)
-      cattr_accessor :ancestry_base_class
-      self.ancestry_base_class = self
+      class_variable_set('@@ancestry_base_class', self)
+      cattr_reader :ancestry_base_class, instance_reader: false
 
       # Touch ancestors after updating
+      # days are limited. need to handle touch in pg case
       cattr_accessor :touch_ancestors
       self.touch_ancestors = options[:touch] || false
 
@@ -36,41 +43,54 @@ module Ancestry
 
       # Include dynamic class methods
       extend Ancestry::ClassMethods
+      extend Ancestry::HasAncestry.ancestry_format_module(ancestry_format)
 
-      cattr_accessor :ancestry_format
-      self.ancestry_format = options[:ancestry_format] || Ancestry.default_ancestry_format
+      attribute ancestry_column, default: ancestry_root
 
-      if ancestry_format == :materialized_path2
-        extend Ancestry::MaterializedPath2
-      else
-        extend Ancestry::MaterializedPath
-      end
-
-      attribute self.ancestry_column, default: self.ancestry_root
-
-      validates self.ancestry_column, ancestry_validation_options
+      validates ancestry_column, ancestry_validation_options(primary_key_format)
 
       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
+      include Ancestry::MaterializedPathPg
 
       # Validate that the ancestor ids don't include own id
       validate :ancestry_exclude_self
 
+      # Validate descendants' depths don't exceed max depth when moving them
+      validate :ancestry_depth_of_descendants, if: :ancestry_changed?
+
       # Update descendants with new ancestry after update
-      after_update :update_descendants_with_new_ancestry
+      if update_strategy == :sql
+        after_update :update_descendants_with_new_ancestry_sql, if: :ancestry_changed?
+      else
+        after_update :update_descendants_with_new_ancestry, if: :ancestry_changed?
+      end
 
       # Apply orphan strategy before destroy
-      before_destroy :apply_orphan_strategy
+      orphan_strategy_helper = "apply_orphan_strategy_#{orphan_strategy}"
+      if method_defined?(orphan_strategy_helper)
+        alias_method :apply_orphan_strategy, orphan_strategy_helper
+        before_destroy :apply_orphan_strategy
+      elsif orphan_strategy.to_s != "none"
+        raise Ancestry::AncestryException, I18n.t("ancestry.invalid_orphan_strategy")
+      end
 
       # Create ancestry column accessor and set to option or default
-      if options[:cache_depth]
+      
+      if options[:cache_depth] == :virtual
+        # NOTE: not setting self.depth_cache_column so the code does not try to update the column
+        depth_cache_sql = options[:depth_cache_column]&.to_s || 'ancestry_depth'
+      elsif options[:cache_depth]
         # Create accessor for column name and set to option or default
-        self.cattr_accessor :depth_cache_column
-        self.depth_cache_column = options[:depth_cache_column] || :ancestry_depth
+        cattr_accessor :depth_cache_column
+        self.depth_cache_column =
+          if options[:cache_depth] == true
+            options[:depth_cache_column]&.to_s || 'ancestry_depth'
+          else
+            options[:cache_depth].to_s
+          end
+        if options[:depth_cache_column]
+          ActiveSupport::Deprecation.warn("has_ancestry :depth_cache_column is deprecated. Use :cache_depth instead.")
+        end
 
         # Cache depth in depth cache column before save
         before_validation :cache_depth
@@ -78,8 +98,19 @@ module Ancestry
 
         # Validate depth column
         validates_numericality_of depth_cache_column, :greater_than_or_equal_to => 0, :only_integer => true, :allow_nil => false
+
+        depth_cache_sql = depth_cache_column
+      else
+        # this is not efficient, but it works
+        depth_cache_sql = ancestry_depth_sql
       end
 
+      scope :before_depth, lambda { |depth| where("#{depth_cache_sql} < ?", depth) }
+      scope :to_depth,     lambda { |depth| where("#{depth_cache_sql} <= ?", depth) }
+      scope :at_depth,     lambda { |depth| where("#{depth_cache_sql} = ?", depth) }
+      scope :from_depth,   lambda { |depth| where("#{depth_cache_sql} >= ?", depth) }
+      scope :after_depth,  lambda { |depth| where("#{depth_cache_sql} > ?", depth) }
+
       # Create counter cache column accessor and set to option or default
       if options[:counter_cache]
         cattr_accessor :counter_cache_column
@@ -90,25 +121,27 @@ module Ancestry
         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(I18n.t("ancestry.named_scope_depth_cache",
-                                                       :scope_name => scope_name
-                                                       )) unless options[:cache_depth]
-          where("#{depth_cache_column} #{operator} ?", depth)
-        }
+      if options[:touch]
+        after_touch :touch_ancestors_callback
+        after_destroy :touch_ancestors_callback
+        after_save :touch_ancestors_callback, if: :saved_changes?
       end
-
-      after_touch :touch_ancestors_callback
-      after_destroy :touch_ancestors_callback
-      after_save :touch_ancestors_callback, if: :saved_changes?
     end
 
     def acts_as_tree(*args)
       return super if defined?(super)
+
       has_ancestry(*args)
     end
+
+    def self.ancestry_format_module(ancestry_format)
+      ancestry_format ||= Ancestry.default_ancestry_format
+      if ancestry_format == :materialized_path2
+        Ancestry::MaterializedPath2
+      else
+        Ancestry::MaterializedPath
+      end
+    end
   end
 end
 

data/lib/ancestry/instance_methods.rb

@@ -1,16 +1,45 @@
+# frozen_string_literal: true
+
 module Ancestry
   module InstanceMethods
     # Validate that the ancestors don't include itself
     def ancestry_exclude_self
-      errors.add(:base, I18n.t("ancestry.exclude_self", class_name: self.class.name.humanize)) if ancestor_ids.include? self.id
+      errors.add(:base, I18n.t("ancestry.exclude_self", class_name: self.class.model_name.human)) if ancestor_ids.include?(id)
+    end
+
+    # Validate that descendants' depths don't exceed max depth when moving them
+    def ancestry_depth_of_descendants
+      return if new_record? || (respond_to?(:previously_new_record?) && previously_new_record?)
+      return unless self.class.respond_to?(:depth_cache_column) && self.class.depth_cache_column
+
+      column = self.class.depth_cache_column
+      validator = self.class.validators_on(column).find do |v|
+        v.is_a?(ActiveModel::Validations::NumericalityValidator) &&
+          (v.options[:less_than_or_equal_to] || v.options[:less_than])
+      end
+      return unless validator
+
+      max_depth = validator.options[:less_than_or_equal_to] || (validator.options[:less_than] - 1)
+
+      old_value = attribute_in_database(self.class.ancestry_column)
+      new_value = read_attribute(self.class.ancestry_column)
+      depth_change = self.class.ancestry_depth_change(old_value, new_value)
+
+      if depth_change > 0
+        max_descendant_depth = unscoped_descendants.maximum(column) || attribute_in_database(column) || 0
+        if max_descendant_depth + depth_change > max_depth
+          errors.add(column, :less_than_or_equal_to, count: max_depth)
+        end
+      end
     end
 
     # Update descendants with new ancestry (after update)
     def update_descendants_with_new_ancestry
-      # If enabled and node is existing and ancestry was updated and the new ancestry is sane ...
-      if !ancestry_callbacks_disabled? && !new_record? && ancestry_changed? && sane_ancestor_ids?
+      # If enabled and the new ancestry is sane ...
+      # The only way the ancestry could be bad is via `update_attribute` with a bad value
+      if !ancestry_callbacks_disabled? && sane_ancestor_ids?
         # ... for each descendant ...
-        unscoped_descendants_before_save.each do |descendant|
+        unscoped_descendants_before_last_save.each do |descendant|
           # ... replace old ancestry with new ancestry
           descendant.without_ancestry_callbacks do
             new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_before_last_save)
@@ -20,37 +49,49 @@ module Ancestry
       end
     end
 
-    # Apply orphan strategy (before destroy - no changes)
-    def apply_orphan_strategy
-      if !ancestry_callbacks_disabled? && !new_record?
-        case self.ancestry_base_class.orphan_strategy
-        when :rootify # make all children root if orphan strategy is rootify
-          unscoped_descendants.each do |descendant|
-            descendant.without_ancestry_callbacks do
-              descendant.update_attribute :ancestor_ids, descendant.ancestor_ids - path_ids
-            end
-          end
-        when :destroy # destroy all descendants if orphan strategy is destroy
-          unscoped_descendants.each do |descendant|
-            descendant.without_ancestry_callbacks do
-              descendant.destroy
-            end
-          end
-        when :adopt # make child elements of this node, child of its parent
-          descendants.each do |descendant|
-            descendant.without_ancestry_callbacks do
-              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(I18n.t("ancestry.cannot_delete_descendants")) unless is_childless?
+    # make all children root if orphan strategy is rootify
+    def apply_orphan_strategy_rootify
+      return if ancestry_callbacks_disabled? || new_record?
+
+      unscoped_descendants.each do |descendant|
+        descendant.without_ancestry_callbacks do
+          descendant.update_attribute :ancestor_ids, descendant.ancestor_ids - path_ids
         end
       end
     end
 
+    # destroy all descendants if orphan strategy is destroy
+    def apply_orphan_strategy_destroy
+      return if ancestry_callbacks_disabled? || new_record?
+
+      unscoped_descendants.ordered_by_ancestry.reverse_order.each do |descendant|
+        descendant.without_ancestry_callbacks do
+          descendant.destroy
+        end
+      end
+    end
+
+    # make child elements of this node, child of its parent
+    def apply_orphan_strategy_adopt
+      return if ancestry_callbacks_disabled? || new_record?
+
+      descendants.each do |descendant|
+        descendant.without_ancestry_callbacks do
+          descendant.update_attribute :ancestor_ids, (descendant.ancestor_ids.delete_if { |x| x == id })
+        end
+      end
+    end
+
+    # throw an exception if it has children
+    def apply_orphan_strategy_restrict
+      return if ancestry_callbacks_disabled? || new_record?
+
+      raise(Ancestry::AncestryException, I18n.t("ancestry.cannot_delete_descendants")) unless is_childless?
+    end
+
     # Touch each of this record's ancestors (after save)
     def touch_ancestors_callback
-      if !ancestry_callbacks_disabled? && self.ancestry_base_class.touch_ancestors
+      if !ancestry_callbacks_disabled?
         # Touch each of the old *and* new ancestors
         unscoped_current_and_previous_ancestors.each do |ancestor|
           ancestor.without_ancestry_callbacks do
@@ -62,7 +103,7 @@ module Ancestry
 
     # Counter Cache
     def increase_parent_counter_cache
-      self.ancestry_base_class.increment_counter counter_cache_column, parent_id
+      self.class.ancestry_base_class.increment_counter counter_cache_column, parent_id
     end
 
     def decrease_parent_counter_cache
@@ -74,16 +115,14 @@ module Ancestry
       return if defined?(@_trigger_destroy_callback) && !@_trigger_destroy_callback
       return if ancestry_callbacks_disabled?
 
-      self.ancestry_base_class.decrement_counter counter_cache_column, parent_id
+      self.class.ancestry_base_class.decrement_counter counter_cache_column, parent_id
     end
 
     def update_parent_counter_cache
-      changed = saved_change_to_attribute?(self.ancestry_base_class.ancestry_column)
+      return unless saved_change_to_attribute?(self.class.ancestry_column)
 
-      return unless changed
-
-      if parent_id_was = parent_id_before_last_save
-        self.ancestry_base_class.decrement_counter counter_cache_column, parent_id_was
+      if (parent_id_was = parent_id_before_last_save)
+        self.class.ancestry_base_class.decrement_counter counter_cache_column, parent_id_was
       end
 
       parent_id && increase_parent_counter_cache
@@ -94,20 +133,20 @@ module Ancestry
     def has_parent?
       ancestor_ids.present?
     end
-    alias :ancestors? :has_parent?
+    alias ancestors? has_parent?
 
     def ancestry_changed?
-      column = self.ancestry_base_class.ancestry_column.to_s
-        # 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))
+      column = self.class.ancestry_column.to_s
+      # 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))
     end
 
     def sane_ancestor_ids?
       current_context, self.validation_context = validation_context, nil
       errors.clear
 
-      attribute = ancestry_base_class.ancestry_column
+      attribute = self.class.ancestry_column
       ancestry_value = send(attribute)
       return true unless ancestry_value
 
@@ -120,9 +159,10 @@ module Ancestry
       self.validation_context = current_context
     end
 
-    def ancestors depth_options = {}
-      return self.ancestry_base_class.none unless has_parent?
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.ancestors_of(self)
+    def ancestors(depth_options = {})
+      return self.class.ancestry_base_class.none unless has_parent?
+
+      self.class.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.ancestors_of(self)
     end
 
     def path_ids
@@ -137,8 +177,8 @@ module Ancestry
       ancestor_ids_in_database + [id]
     end
 
-    def path depth_options = {}
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.inpath_of(self)
+    def path(depth_options = {})
+      self.class.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.inpath_of(self)
     end
 
     def depth
@@ -146,29 +186,29 @@ module Ancestry
     end
 
     def cache_depth
-      write_attribute self.ancestry_base_class.depth_cache_column, depth
+      write_attribute self.class.ancestry_base_class.depth_cache_column, depth
     end
 
     def ancestor_of?(node)
-      node.ancestor_ids.include?(self.id)
+      node.ancestor_ids.include?(id)
     end
 
     # Parent
 
     # currently parent= does not work in after save callbacks
     # assuming that parent hasn't changed
-    def parent= parent
+    def parent=(parent)
       self.ancestor_ids = parent ? parent.path_ids : []
     end
 
-    def parent_id= new_parent_id
+    def parent_id=(new_parent_id)
       self.parent = new_parent_id.present? ? unscoped_find(new_parent_id) : nil
     end
 
     def parent_id
       ancestor_ids.last if has_parent?
     end
-    alias :parent_id? :ancestors?
+    alias parent_id? ancestors?
 
     def parent
       if has_parent?
@@ -179,7 +219,7 @@ module Ancestry
     end
 
     def parent_of?(node)
-      self.id == node.parent_id
+      id == node.parent_id
     end
 
     # Root
@@ -199,24 +239,24 @@ module Ancestry
     def is_root?
       !has_parent?
     end
-    alias :root? :is_root?
+    alias root? is_root?
 
     def root_of?(node)
-      self.id == node.root_id
+      id == node.root_id
     end
 
     # Children
 
     def children
-      self.ancestry_base_class.children_of(self)
+      self.class.ancestry_base_class.children_of(self)
     end
 
     def child_ids
-      children.pluck(self.ancestry_base_class.primary_key)
+      children.pluck(self.class.primary_key)
     end
 
     def has_children?
-      self.children.exists?
+      children.exists?
     end
     alias_method :children?, :has_children?
 
@@ -226,22 +266,21 @@ module Ancestry
     alias_method :childless?, :is_childless?
 
     def child_of?(node)
-      self.parent_id == node.id
+      parent_id == node.id
     end
 
     # Siblings
 
     def siblings
-      self.ancestry_base_class.siblings_of(self)
+      self.class.ancestry_base_class.siblings_of(self).where.not(self.class.primary_key => id)
     end
 
-    # NOTE: includes self
     def sibling_ids
-      siblings.pluck(self.ancestry_base_class.primary_key)
+      siblings.pluck(self.class.primary_key)
     end
 
     def has_siblings?
-      self.siblings.count > 1
+      siblings.exists?
     end
     alias_method :siblings?, :has_siblings?
 
@@ -251,17 +290,17 @@ module Ancestry
     alias_method :only_child?, :is_only_child?
 
     def sibling_of?(node)
-      self.ancestor_ids == node.ancestor_ids
+      ancestor_ids == node.ancestor_ids
     end
 
     # Descendants
 
-    def descendants depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).descendants_of(self)
+    def descendants(depth_options = {})
+      self.class.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).descendants_of(self)
     end
 
-    def descendant_ids depth_options = {}
-      descendants(depth_options).pluck(self.ancestry_base_class.primary_key)
+    def descendant_ids(depth_options = {})
+      descendants(depth_options).pluck(self.class.primary_key)
     end
 
     def descendant_of?(node)
@@ -270,12 +309,12 @@ module Ancestry
 
     # Indirects
 
-    def indirects depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).indirects_of(self)
+    def indirects(depth_options = {})
+      self.class.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).indirects_of(self)
     end
 
-    def indirect_ids depth_options = {}
-      indirects(depth_options).pluck(self.ancestry_base_class.primary_key)
+    def indirect_ids(depth_options = {})
+      indirects(depth_options).pluck(self.class.primary_key)
     end
 
     def indirect_of?(node)
@@ -284,12 +323,16 @@ module Ancestry
 
     # Subtree
 
-    def subtree depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).subtree_of(self)
+    def subtree(depth_options = {})
+      self.class.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).subtree_of(self)
     end
 
-    def subtree_ids depth_options = {}
-      subtree(depth_options).pluck(self.ancestry_base_class.primary_key)
+    def subtree_ids(depth_options = {})
+      subtree(depth_options).pluck(self.class.primary_key)
+    end
+
+    def in_subtree_of?(node)
+      id == node.id || descendant_of?(node)
     end
 
     # Callback disabling
@@ -305,36 +348,35 @@ module Ancestry
       defined?(@disable_ancestry_callbacks) && @disable_ancestry_callbacks
     end
 
-  private
+    private
+
     def unscoped_descendants
       unscoped_where do |scope|
-        scope.where self.ancestry_base_class.descendant_conditions(self)
+        scope.where(self.class.ancestry_base_class.descendant_conditions(self))
       end
     end
 
-    def unscoped_descendants_before_save
+    def unscoped_descendants_before_last_save
       unscoped_where do |scope|
-        scope.where self.ancestry_base_class.descendant_before_save_conditions(self)
+        scope.where(self.class.ancestry_base_class.descendant_before_last_save_conditions(self))
       end
     end
 
     # works with after save context (hence before_last_save)
     def unscoped_current_and_previous_ancestors
       unscoped_where do |scope|
-        scope.where scope.primary_key => (ancestor_ids + ancestor_ids_before_last_save).uniq
+        scope.where(scope.primary_key => (ancestor_ids + ancestor_ids_before_last_save).uniq)
       end
     end
 
-    def unscoped_find id
+    def unscoped_find(id)
       unscoped_where do |scope|
-        scope.find id
+        scope.find(id)
       end
     end
 
-    def unscoped_where
-      self.ancestry_base_class.unscoped_where do |scope|
-        yield scope
-      end
+    def unscoped_where(&block)
+      self.class.ancestry_base_class.unscoped_where(&block)
     end
   end
 end

data/lib/ancestry/locales/en.yml

@@ -10,7 +10,6 @@ en:
     option_must_be_hash: "Options for has_ancestry must be in a hash."
     unknown_option: "Unknown option for has_ancestry: %{key} => %{value}."
     unknown_format: "Unknown ancestry format: %{value}."
-    named_scope_depth_cache: "Named scope '%{scope_name}' is only available when depth caching is enabled."
 
     exclude_self: "%{class_name} cannot be a descendant of itself."
     cannot_delete_descendants: "Cannot delete record because it has descendants."