ancestry 3.0.6 → 4.0.0

data/lib/ancestry/locales/en.yml

@@ -0,0 +1,16 @@
+en:
+  ancestry:
+    unknown_depth_option: "Unknown depth option: %{scope_name}."
+    invalid_orphan_strategy: "Invalid orphan strategy, valid ones are :rootify, :adopt, :restrict and :destroy."
+    invalid_ancestry_column: "Invalid format for ancestry column of node %{node_id}: %{ancestry_column}."
+    reference_nonexistent_node: "Reference to nonexistent node in node %{node_id}: %{ancestor_id}."
+    conflicting_parent_id: "Conflicting parent id found in node %{node_id}: %{parent_id} for node %{node_id} while expecting %{expected}"
+    cannot_rebuild_depth_cache: "Cannot rebuild depth cache for model without depth caching."
+
+    option_must_be_hash: "Options for has_ancestry must be in a hash."
+    unknown_option: "Unknown option for has_ancestry: %{key} => %{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."
+    no_child_for_new_record: "No child ancestry for new record. Save record before performing tree operations."

data/lib/ancestry/materialized_path.rb

@@ -1,72 +1,145 @@
 module Ancestry
   module MaterializedPath
+    BEFORE_LAST_SAVE_SUFFIX = '_before_last_save'.freeze
+    IN_DATABASE_SUFFIX = '_in_database'.freeze
+    ANCESTRY_DELIMITER='/'.freeze
+
     def self.extended(base)
-      base.validates_format_of base.ancestry_column, :with => Ancestry::ANCESTRY_PATTERN, :allow_nil => true
       base.send(:include, InstanceMethods)
     end
 
-    def root_conditions
-      arel_table[ancestry_column].eq(nil)
+    def path_of(object)
+      to_node(object).path
+    end
+
+    def roots
+      where(arel_table[ancestry_column].eq(nil))
     end
 
-    def ancestor_conditions(object)
+    def ancestors_of(object)
       t = arel_table
       node = to_node(object)
-      t[primary_key].in(node.ancestor_ids)
+      where(t[primary_key].in(node.ancestor_ids))
     end
 
-    def path_conditions(object)
+    def inpath_of(object)
       t = arel_table
       node = to_node(object)
-      t[primary_key].in(node.path_ids)
+      where(t[primary_key].in(node.path_ids))
     end
 
-    def child_conditions(object)
+    def children_of(object)
       t = arel_table
       node = to_node(object)
-      t[ancestry_column].eq(node.child_ancestry)
+      where(t[ancestry_column].eq(node.child_ancestry))
     end
 
     # indirect = anyone who is a descendant, but not a child
-    def indirect_conditions(object)
+    def indirects_of(object)
       t = arel_table
       node = to_node(object)
-      # rails has case sensitive matching.
-      if ActiveRecord::VERSION::MAJOR >= 5
-        t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true)
-      else
-        t[ancestry_column].matches("#{node.child_ancestry}/%")
-      end
+      where(t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true))
     end
 
+    def descendants_of(object)
+      where(descendant_conditions(object))
+    end
+
+    # deprecated
     def descendant_conditions(object)
       t = arel_table
       node = to_node(object)
-      # rails has case sensitive matching.
-      if ActiveRecord::VERSION::MAJOR >= 5
-        t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true).or(t[ancestry_column].eq(node.child_ancestry))
-      else
-        t[ancestry_column].matches("#{node.child_ancestry}/%").or(t[ancestry_column].eq(node.child_ancestry))
-      end
+      t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true).or(t[ancestry_column].eq(node.child_ancestry))
     end
 
-    def subtree_conditions(object)
+    def subtree_of(object)
       t = arel_table
       node = to_node(object)
-      descendant_conditions(node).or(t[primary_key].eq(node.id))
+      where(descendant_conditions(node).or(t[primary_key].eq(node.id)))
     end
 
-    def sibling_conditions(object)
+    def siblings_of(object)
       t = arel_table
       node = to_node(object)
-      t[ancestry_column].eq(node[ancestry_column])
+      where(t[ancestry_column].eq(node[ancestry_column].presence))
+    end
+
+    def ordered_by_ancestry(order = nil)
+      if %w(mysql mysql2 sqlite sqlite3).include?(connection.adapter_name.downcase)
+        reorder(arel_table[ancestry_column], order)
+      elsif %w(postgresql).include?(connection.adapter_name.downcase) && ActiveRecord::VERSION::STRING >= "6.1"
+        reorder(Arel::Nodes::Ascending.new(arel_table[ancestry_column]).nulls_first, order)
+      else
+        reorder(
+          Arel::Nodes::Ascending.new(Arel::Nodes::NamedFunction.new('COALESCE', [arel_table[ancestry_column], Arel.sql("''")])),
+          order
+        )
+      end
+    end
+
+    def ordered_by_ancestry_and(order)
+      ordered_by_ancestry(order)
     end
 
     module InstanceMethods
+
       # Validates the ancestry, but can also be applied if validation is bypassed to determine if children should be affected
       def sane_ancestry?
         ancestry_value = read_attribute(self.ancestry_base_class.ancestry_column)
-        ancestry_value.nil? || (ancestry_value.to_s =~ Ancestry::ANCESTRY_PATTERN && !ancestor_ids.include?(self.id))
+        (ancestry_value.nil? || !ancestor_ids.include?(self.id)) && valid?
+      end
+
+      # optimization - better to go directly to column and avoid parsing
+      def ancestors?
+        read_attribute(self.ancestry_base_class.ancestry_column).present?
+      end
+      alias :has_parent? :ancestors?
+
+      def ancestor_ids=(value)
+        col = self.ancestry_base_class.ancestry_column
+        value.present? ? write_attribute(col, value.join(ANCESTRY_DELIMITER)) : write_attribute(col, nil)
+      end
+
+      def ancestor_ids
+        parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
+      end
+
+      def ancestor_ids_in_database
+        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}"))
+      end
+
+      def ancestor_ids_before_last_save
+        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}"))
+      end
+
+      def parent_id_before_last_save
+        ancestry_was = send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}")
+        return unless ancestry_was.present?
+
+        parse_ancestry_column(ancestry_was).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)
+      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
+      def child_ancestry
+        # New records cannot have children
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        path_was = self.send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}")
+        path_was.blank? ? id.to_s : "#{path_was}/#{id}"
+      end
+
+      private
+
+      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
     end
   end

data/lib/ancestry/materialized_path_pg.rb

@@ -0,0 +1,23 @@
+module Ancestry
+  module MaterializedPathPg
+    # Update descendants with new ancestry (before save)
+    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_ancestry?
+        ancestry_column = ancestry_base_class.ancestry_column
+        old_ancestry = path_ids_in_database.join(Ancestry::MaterializedPath::ANCESTRY_DELIMITER)
+        new_ancestry = path_ids.join(Ancestry::MaterializedPath::ANCESTRY_DELIMITER)
+        update_clause = [
+          "#{ancestry_column} = regexp_replace(#{ancestry_column}, '^#{old_ancestry}', '#{new_ancestry}')"
+        ]
+
+        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, '^#{old_ancestry}', '#{new_ancestry}'), '\\d', '', 'g')) + 1"
+        end
+
+        unscoped_descendants.update_all update_clause.join(', ')
+      end
+    end
+  end
+end

data/lib/ancestry/version.rb

@@ -1,3 +1,3 @@
 module Ancestry
-  VERSION = "3.0.6"
+  VERSION = "4.0.0"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ancestry
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 4.0.0
 platform: ruby
 authors:
 - Stefan Kroes
 - Keenan Brock
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-04-24 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,16 +17,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 5.2.4.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 5.2.4.5
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -59,44 +59,16 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -111,28 +83,28 @@ dependencies:
         version: '0'
 description: |2
     Ancestry allows the records of a ActiveRecord model to be organized 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.
+    structure, using the materialized path pattern. It exposes the standard
+    relations (ancestors, parent, root, children, siblings, descendants)
+    and allows them to be fetched in a single query. Additional features include
+    named scopes, integrity checking, integrity restoration, arrangement
+    of (sub)tree into hashes and different strategies for dealing with orphaned
+    records.
 email: keenan@thebrocks.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - MIT-LICENSE
 - README.md
-- ancestry.gemspec
-- init.rb
-- install.rb
 - lib/ancestry.rb
 - lib/ancestry/class_methods.rb
 - lib/ancestry/exceptions.rb
 - lib/ancestry/has_ancestry.rb
 - lib/ancestry/instance_methods.rb
+- lib/ancestry/locales/en.yml
 - lib/ancestry/materialized_path.rb
+- lib/ancestry/materialized_path_pg.rb
 - lib/ancestry/version.rb
 homepage: https://github.com/stefankroes/ancestry
 licenses:
@@ -142,7 +114,8 @@ 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
-post_install_message: 
+post_install_message: Thank you for installing Ancestry. You can visit http://github.com/stefankroes/ancestry
+  to read the documentation.
 rdoc_options: []
 require_paths:
 - lib
@@ -150,15 +123,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Organize ActiveRecord model into a tree structure
 test_files: []

data/ancestry.gemspec

@@ -1,53 +0,0 @@
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
-require 'ancestry/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'ancestry'
-  s.summary     = 'Organize ActiveRecord model into a tree structure'
-  s.description = <<-EOF
-  Ancestry allows the records of a ActiveRecord model to be organized 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.
-EOF
-  s.metadata = {
-    "homepage_uri" => "https://github.com/stefankroes/ancestry",
-    "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",
-  }
-  s.version = Ancestry::VERSION
-
-  s.authors  = ['Stefan Kroes', 'Keenan Brock']
-  s.email    = 'keenan@thebrocks.net'
-  s.homepage = 'https://github.com/stefankroes/ancestry'
-  s.license  = 'MIT'
-
-  s.files = [
-    'ancestry.gemspec',
-    'init.rb',
-    'install.rb',
-    'lib/ancestry.rb',
-    'lib/ancestry/has_ancestry.rb',
-    'lib/ancestry/exceptions.rb',
-    'lib/ancestry/class_methods.rb',
-    'lib/ancestry/instance_methods.rb',
-    'lib/ancestry/materialized_path.rb',
-    'lib/ancestry/version.rb',
-    'MIT-LICENSE',
-    'README.md'
-  ]
-  
-  s.required_ruby_version     = '>= 1.8.7'
-  s.add_runtime_dependency 'activerecord', '>= 3.2.0'
-  s.add_development_dependency 'rdoc'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'rake',      '~> 10.0'
-  s.add_development_dependency 'test-unit'
-  s.add_development_dependency 'minitest'
-  s.add_development_dependency 'sqlite3'
-end

data/init.rb

@@ -1 +0,0 @@
-require 'ancestry'

data/install.rb

@@ -1 +0,0 @@
-puts "Thank you for installing Ancestry. You can visit http://github.com/stefankroes/ancestry to read the documentation."