ancestry 4.3.3 → 5.1.0

data/lib/ancestry/materialized_path.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ancestry
   # store ancestry as grandparent_id/parent_id
   # root a=nil,id=1   children=id,id/%      == 1, 1/%
@@ -28,16 +30,13 @@ module Ancestry
     end
 
     def children_of(object)
-      t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].eq(node.child_ancestry))
+      where(arel_table[ancestry_column].eq(node.child_ancestry))
     end
 
-    # indirect = anyone who is a descendant, but not a child
     def indirects_of(object)
-      t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].matches("#{node.child_ancestry}#{ancestry_delimiter}%", nil, true))
+      where(MaterializedPath.indirects_condition(arel_table[ancestry_column], node.child_ancestry, ancestry_delimiter))
     end
 
     def descendants_of(object)
@@ -45,30 +44,27 @@ module Ancestry
     end
 
     def descendants_by_ancestry(ancestry)
-      t = arel_table
-      t[ancestry_column].matches("#{ancestry}#{ancestry_delimiter}%", nil, true).or(t[ancestry_column].eq(ancestry))
+      MaterializedPath.descendants_condition(arel_table[ancestry_column], ancestry, ancestry_delimiter)
     end
 
     def descendant_conditions(object)
       node = to_node(object)
-      descendants_by_ancestry( node.child_ancestry )
+      descendants_by_ancestry(node.child_ancestry)
     end
 
-    def descendant_before_save_conditions(object)
+    def descendant_before_last_save_conditions(object)
       node = to_node(object)
-      descendants_by_ancestry( node.child_ancestry_before_save )
+      descendants_by_ancestry(node.child_ancestry_before_last_save)
     end
 
     def subtree_of(object)
-      t = arel_table
       node = to_node(object)
-      descendants_of(node).or(where(t[primary_key].eq(node.id)))
+      descendants_of(node).or(where(arel_table[primary_key].eq(node.id)))
     end
 
     def siblings_of(object)
-      t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].eq(node[ancestry_column].presence))
+      where(arel_table[ancestry_column].eq(node[ancestry_column].presence))
     end
 
     def ordered_by_ancestry(order = nil)
@@ -92,86 +88,153 @@ module Ancestry
       nil
     end
 
-    private
+    def child_ancestry_sql
+      MaterializedPath.child_ancestry_sql(table_name, ancestry_column, primary_key, ancestry_delimiter, connection.adapter_name.downcase)
+    end
 
-    def ancestry_validation_options
-      {
-        format: { with: ancestry_format_regexp },
-        allow_nil: ancestry_nil_allowed?
+    def ancestry_depth_sql
+      @ancestry_depth_sql ||= MaterializedPath.construct_depth_sql(table_name, ancestry_column, ancestry_delimiter)
+    end
+
+    def generate_ancestry(ancestor_ids)
+      MaterializedPath.generate(ancestor_ids, ancestry_delimiter, ancestry_root)
+    end
+
+    def parse_ancestry_column(obj)
+      MaterializedPath.parse(obj, ancestry_root, ancestry_delimiter, primary_key_is_an_integer?)
+    end
+
+    def ancestry_depth_change(old_value, new_value)
+      parse_ancestry_column(new_value).size - parse_ancestry_column(old_value).size
+    end
+
+    def self.generate(ancestor_ids, delimiter, root)
+      if ancestor_ids.present? && ancestor_ids.any?
+        ancestor_ids.join(delimiter)
+      else
+        root
+      end
+    end
+
+    def self.parse(obj, root, delimiter, integer_pk)
+      return [] if obj.nil? || obj == root
+
+      obj_ids = obj.split(delimiter).delete_if(&:blank?)
+      integer_pk ? obj_ids.map!(&:to_i) : obj_ids
+    end
+
+    def self.child_ancestry_value(ancestry_value, id, delimiter)
+      [ancestry_value, id].compact.join(delimiter)
+    end
+
+    # Arel condition: descendants have ancestry matching child_ancestry or starting with child_ancestry/
+    def self.descendants_condition(attr, child_ancestry, delimiter)
+      attr.matches("#{child_ancestry}#{delimiter}%", nil, true).or(attr.eq(child_ancestry))
+    end
+
+    # Arel condition: indirects have ancestry matching child_ancestry/*/
+    def self.indirects_condition(attr, child_ancestry, delimiter)
+      attr.matches("#{child_ancestry}#{delimiter}%", nil, true)
+    end
+
+    def concat(*args)
+      MaterializedPath.concat(connection.adapter_name.downcase, *args)
+    end
+
+    def self.concat(adapter, *args)
+      if %w(sqlite sqlite3).include?(adapter)
+        args.join('||')
+      else
+        %{CONCAT(#{args.join(', ')})}
+      end
+    end
+
+    def self.child_ancestry_sql(table_name, ancestry_column, primary_key, delimiter, adapter)
+      pk_sql = concat(adapter, "#{table_name}.#{primary_key}")
+      full_sql = concat(adapter, "#{table_name}.#{ancestry_column}", "'#{delimiter}'", "#{table_name}.#{primary_key}")
+      %{
+        CASE WHEN #{table_name}.#{ancestry_column} IS NULL THEN #{pk_sql}
+        ELSE      #{full_sql}
+        END
       }
     end
 
-    def ancestry_nil_allowed?
-      true
+    def self.construct_depth_sql(table_name, ancestry_column, ancestry_delimiter)
+      tmp = %{(LENGTH(#{table_name}.#{ancestry_column}) - LENGTH(REPLACE(#{table_name}.#{ancestry_column},'#{ancestry_delimiter}','')))}
+      tmp += "/#{ancestry_delimiter.size}" if ancestry_delimiter.size > 1
+      "(CASE WHEN #{table_name}.#{ancestry_column} IS NULL THEN 0 ELSE 1 + #{tmp} END)"
     end
 
-    def ancestry_format_regexp
-      /\A#{ancestry_primary_key_format}(#{Regexp.escape(ancestry_delimiter)}#{ancestry_primary_key_format})*\z/.freeze
+    def self.validation_options(primary_key_format, delimiter)
+      {
+        format: {with: /\A#{primary_key_format}(#{Regexp.escape(delimiter)}#{primary_key_format})*\z/.freeze},
+        allow_nil: true
+      }
+    end
+
+    private
+
+    def ancestry_validation_options(ancestry_primary_key_format)
+      MaterializedPath.validation_options(ancestry_primary_key_format, ancestry_delimiter)
     end
 
     module InstanceMethods
       # optimization - better to go directly to column and avoid parsing
       def ancestors?
-        read_attribute(self.ancestry_base_class.ancestry_column) != self.ancestry_base_class.ancestry_root
+        read_attribute(self.class.ancestry_column) != self.class.ancestry_root
       end
-      alias :has_parent? :ancestors?
+      alias has_parent? ancestors?
 
       def ancestor_ids=(value)
-        write_attribute(self.ancestry_base_class.ancestry_column, generate_ancestry(value))
+        write_attribute(self.class.ancestry_column, self.class.generate_ancestry(value))
       end
 
       def ancestor_ids
-        parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
+        MaterializedPath.parse(read_attribute(self.class.ancestry_column), self.class.ancestry_root, self.class.ancestry_delimiter, self.class.primary_key_is_an_integer?)
       end
 
       def ancestor_ids_in_database
-        parse_ancestry_column(attribute_in_database(self.class.ancestry_column))
+        MaterializedPath.parse(attribute_in_database(self.class.ancestry_column), self.class.ancestry_root, self.class.ancestry_delimiter, self.class.primary_key_is_an_integer?)
       end
 
       def ancestor_ids_before_last_save
-        parse_ancestry_column(attribute_before_last_save(self.ancestry_base_class.ancestry_column))
+        MaterializedPath.parse(attribute_before_last_save(self.class.ancestry_column), self.class.ancestry_root, self.class.ancestry_delimiter, self.class.primary_key_is_an_integer?)
       end
 
       def parent_id_in_database
-        parse_ancestry_column(attribute_in_database(self.class.ancestry_column)).last
+        MaterializedPath.parse(attribute_in_database(self.class.ancestry_column), self.class.ancestry_root, self.class.ancestry_delimiter, self.class.primary_key_is_an_integer?).last
       end
 
       def parent_id_before_last_save
-        parse_ancestry_column(attribute_before_last_save(self.ancestry_base_class.ancestry_column)).last
+        MaterializedPath.parse(attribute_before_last_save(self.class.ancestry_column), self.class.ancestry_root, self.class.ancestry_delimiter, self.class.primary_key_is_an_integer?).last
       end
 
       # optimization - better to go directly to column and avoid parsing
       def sibling_of?(node)
-        self.read_attribute(self.ancestry_base_class.ancestry_column) == node.read_attribute(self.ancestry_base_class.ancestry_column)
+        read_attribute(self.class.ancestry_column) == node.read_attribute(node.class.ancestry_column)
       end
 
-      # private (public so class methods can find it)
-      # The ancestry value for this record's children (before save)
-      # This is technically child_ancestry_was
+      # The ancestry value for this record's children
+      # This can also be thought of as the ancestry value for the path
+      # If this is a new record, it has no id, and it is not valid.
+      # NOTE: This could have been called child_ancestry_in_database
+      #       the child records were created from the version in the database
       def child_ancestry
-        # New records cannot have children
-        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
-        [attribute_in_database(self.ancestry_base_class.ancestry_column), id].compact.join(self.ancestry_base_class.ancestry_delimiter)
-      end
+        raise(Ancestry::AncestryException, I18n.t("ancestry.no_child_for_new_record")) if new_record?
 
-      def child_ancestry_before_save
-        # New records cannot have children
-        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
-        [attribute_before_last_save(self.ancestry_base_class.ancestry_column), id].compact.join(self.ancestry_base_class.ancestry_delimiter)
+        MaterializedPath.child_ancestry_value(attribute_in_database(self.class.ancestry_column), id, self.class.ancestry_delimiter)
       end
 
-      def parse_ancestry_column(obj)
-        return [] if obj.nil? || obj == self.ancestry_base_class.ancestry_root
-        obj_ids = obj.split(self.ancestry_base_class.ancestry_delimiter).delete_if(&:blank?)
-        self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
-      end
-
-      def generate_ancestry(ancestor_ids)
-        if ancestor_ids.present? && ancestor_ids.any?
-          ancestor_ids.join(self.ancestry_base_class.ancestry_delimiter)
-        else
-          self.ancestry_base_class.ancestry_root
+      # The ancestry value for this record's old children
+      # Currently used in an after_update via unscoped_descendants_before_last_save
+      # to find the old children and bring them along (or to )
+      # This is not valid in a new record's after_save.
+      def child_ancestry_before_last_save
+        if new_record? || (respond_to?(:previously_new_record?) && previously_new_record?)
+          raise Ancestry::AncestryException, I18n.t("ancestry.no_child_for_new_record")
         end
+
+        MaterializedPath.child_ancestry_value(attribute_before_last_save(self.class.ancestry_column), id, self.class.ancestry_delimiter)
       end
     end
   end

data/lib/ancestry/materialized_path2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ancestry
   # store ancestry as /grandparent_id/parent_id/
   # root: a=/,id=1    children=#{a}#{id}/% == /1/%
@@ -11,9 +13,8 @@ module Ancestry
     end
 
     def indirects_of(object)
-      t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].matches("#{node.child_ancestry}%#{ancestry_delimiter}%", nil, true))
+      where(MaterializedPath2.indirects_condition(arel_table[ancestry_column], node.child_ancestry, ancestry_delimiter))
     end
 
     def ordered_by_ancestry(order = nil)
@@ -21,42 +22,86 @@ module Ancestry
     end
 
     def descendants_by_ancestry(ancestry)
-      arel_table[ancestry_column].matches("#{ancestry}%", nil, true)
+      MaterializedPath2.descendants_condition(arel_table[ancestry_column], ancestry, ancestry_delimiter)
     end
 
     def ancestry_root
       ancestry_delimiter
     end
 
-    private
+    def child_ancestry_sql
+      MaterializedPath2.child_ancestry_sql(table_name, ancestry_column, primary_key, ancestry_delimiter, connection.adapter_name.downcase)
+    end
+
+    def ancestry_depth_sql
+      @ancestry_depth_sql ||= MaterializedPath2.construct_depth_sql(table_name, ancestry_column, ancestry_delimiter)
+    end
+
+    def generate_ancestry(ancestor_ids)
+      MaterializedPath2.generate(ancestor_ids, ancestry_delimiter, ancestry_root)
+    end
+
+    def self.generate(ancestor_ids, delimiter, root)
+      if ancestor_ids.present? && ancestor_ids.any?
+        "#{delimiter}#{ancestor_ids.join(delimiter)}#{delimiter}"
+      else
+        root
+      end
+    end
+
+    def self.child_ancestry_value(ancestry_value, id, delimiter)
+      "#{ancestry_value}#{id}#{delimiter}"
+    end
 
-    def ancestry_nil_allowed?
-      false
+    def self.child_ancestry_sql(table_name, ancestry_column, primary_key, delimiter, adapter)
+      MaterializedPath.concat(adapter, "#{table_name}.#{ancestry_column}", "#{table_name}.#{primary_key}", "'#{delimiter}'")
     end
 
-    def ancestry_format_regexp
-      /\A#{Regexp.escape(ancestry_delimiter)}(#{ancestry_primary_key_format}#{Regexp.escape(ancestry_delimiter)})*\z/.freeze
+    # mp2: descendants just use LIKE (trailing delimiter prevents false prefix matches)
+    def self.descendants_condition(attr, child_ancestry, _delimiter)
+      attr.matches("#{child_ancestry}%", nil, true)
+    end
+
+    # mp2: indirects match child_ancestry + at least one more segment
+    def self.indirects_condition(attr, child_ancestry, delimiter)
+      attr.matches("#{child_ancestry}%#{delimiter}%", nil, true)
+    end
+
+    # module method
+    def self.construct_depth_sql(table_name, ancestry_column, ancestry_delimiter)
+      tmp = %{(LENGTH(#{table_name}.#{ancestry_column}) - LENGTH(REPLACE(#{table_name}.#{ancestry_column},'#{ancestry_delimiter}','')))}
+      tmp += "/#{ancestry_delimiter.size}" if ancestry_delimiter.size > 1
+      "(#{tmp} -1)"
+    end
+
+    def self.validation_options(primary_key_format, delimiter)
+      {
+        format: {with: /\A#{Regexp.escape(delimiter)}(#{primary_key_format}#{Regexp.escape(delimiter)})*\z/.freeze},
+        allow_nil: false
+      }
+    end
+
+    private
+
+    def ancestry_validation_options(ancestry_primary_key_format)
+      MaterializedPath2.validation_options(ancestry_primary_key_format, ancestry_delimiter)
     end
 
     module InstanceMethods
+      # Please see notes for MaterializedPath#child_ancestry
       def child_ancestry
-        # New records cannot have children
-        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
-        "#{attribute_in_database(self.ancestry_base_class.ancestry_column)}#{id}#{self.ancestry_base_class.ancestry_delimiter}"
-      end
+        raise(Ancestry::AncestryException, I18n.t("ancestry.no_child_for_new_record")) if new_record?
 
-      def child_ancestry_before_save
-        # New records cannot have children
-        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
-        "#{attribute_before_last_save(self.ancestry_base_class.ancestry_column)}#{id}#{self.ancestry_base_class.ancestry_delimiter}"
+        MaterializedPath2.child_ancestry_value(attribute_in_database(self.class.ancestry_column), id, self.class.ancestry_delimiter)
       end
 
-      def generate_ancestry(ancestor_ids)
-        if ancestor_ids.present? && ancestor_ids.any?
-          "#{self.ancestry_base_class.ancestry_delimiter}#{ancestor_ids.join(self.ancestry_base_class.ancestry_delimiter)}#{self.ancestry_base_class.ancestry_delimiter}"
-        else
-          self.ancestry_base_class.ancestry_root
+      # Please see notes for MaterializedPath#child_ancestry_before_last_save
+      def child_ancestry_before_last_save
+        if new_record? || (respond_to?(:previously_new_record?) && previously_new_record?)
+          raise(Ancestry::AncestryException, I18n.t("ancestry.no_child_for_new_record"))
         end
+
+        MaterializedPath2.child_ancestry_value(attribute_before_last_save(self.class.ancestry_column), id, self.class.ancestry_delimiter)
       end
     end
   end

data/lib/ancestry/materialized_path_pg.rb

@@ -1,23 +1,42 @@
+# frozen_string_literal: true
+
 module Ancestry
   module MaterializedPathPg
-    # Update descendants with new ancestry (after update)
-    def update_descendants_with_new_ancestry
+    # Update descendants with new ancestry using a single SQL statement (after update)
+    def update_descendants_with_new_ancestry_sql
       # 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?
-        ancestry_column = ancestry_base_class.ancestry_column
-        old_ancestry = generate_ancestry( path_ids_before_last_save )
-        new_ancestry = generate_ancestry( path_ids )
-        update_clause = [
-          "#{ancestry_column} = regexp_replace(#{ancestry_column}, '^#{Regexp.escape(old_ancestry)}', '#{new_ancestry}')"
-        ]
+      # The only way the ancestry could be bad is via `update_attribute` with a bad value
+      if !ancestry_callbacks_disabled? && sane_ancestor_ids?
+        old_ancestry = self.class.generate_ancestry(path_ids_before_last_save)
+        new_ancestry = self.class.generate_ancestry(path_ids)
+        # Replace old ancestry prefix with new ancestry:
+        # CONCAT(new_ancestry, SUBSTRING(column, LENGTH(old_ancestry) + 1))
+        column = self.class.ancestry_column
+        replace_sql = self.class.concat("'#{new_ancestry}'", "SUBSTRING(#{column}, #{old_ancestry.length + 1})")
+        update_clause = {
+          column => Arel.sql(replace_sql)
+        }
 
-        if ancestry_base_class.respond_to?(:depth_cache_column) && respond_to?(ancestry_base_class.depth_cache_column)
-          depth_cache_column = ancestry_base_class.depth_cache_column.to_s
-          update_clause << "#{depth_cache_column} = length(regexp_replace(regexp_replace(ancestry, '^#{Regexp.escape(old_ancestry)}', '#{new_ancestry}'), '[^#{ancestry_base_class.ancestry_delimiter}]', '', 'g')) #{ancestry_base_class.ancestry_format == :materialized_path2 ? '-' : '+'} 1"
+        current_time = current_time_from_proper_timezone
+        timestamp_attributes_for_update_in_model.each do |column|
+          update_clause[column] = current_time
         end
 
-        unscoped_descendants_before_save.update_all update_clause.join(', ')
+        update_descendants_hook(update_clause, old_ancestry, new_ancestry)
+        unscoped_descendants_before_last_save.update_all update_clause
+      end
+    end
+
+    def update_descendants_hook(update_clause, old_ancestry, new_ancestry)
+      if self.class.respond_to?(:depth_cache_column)
+        depth_cache_column = self.class.depth_cache_column
+        depth_change = self.class.ancestry_depth_change(old_ancestry, new_ancestry)
+
+        if depth_change != 0
+          update_clause[depth_cache_column] = Arel.sql("#{depth_cache_column} + #{depth_change}")
+        end
       end
+      update_clause
     end
   end
 end

data/lib/ancestry/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ancestry
-  VERSION = '4.3.3'
+  VERSION = '5.1.0'
 end

data/lib/ancestry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'ancestry/version'
 require_relative 'ancestry/class_methods'
 require_relative 'ancestry/instance_methods'
@@ -8,7 +10,7 @@ require_relative 'ancestry/materialized_path2'
 require_relative 'ancestry/materialized_path_pg'
 
 I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)),
-                                 'ancestry', 'locales', '*.{rb,yml}').to_s]
+                                'ancestry', 'locales', '*.{rb,yml}').to_s]
 
 module Ancestry
   @@default_update_strategy = :ruby

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ancestry
 version: !ruby/object:Gem::Version
-  version: 4.3.3
+  version: 5.1.0
 platform: ruby
 authors:
 - Stefan Kroes
 - Keenan Brock
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -25,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.2.6
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +142,7 @@ metadata:
   changelog_uri: https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/stefankroes/ancestry/
   bug_tracker_uri: https://github.com/stefankroes/ancestry/issues
+  rubygems_mfa_required: 'true'
 post_install_message: Thank you for installing Ancestry. You can visit http://github.com/stefankroes/ancestry
   to read the documentation.
 rdoc_options: []
@@ -145,8 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Organize ActiveRecord model into a tree structure
 test_files: []