closure_tree 9.2.0 → 9.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ace270a69b46da9e3ba8594cb5299e0eb3d9b222f3261c6304566cdbe1f5c7bd
-  data.tar.gz: ea4dccd196cf9278d510f89fa62d5e892916f2effa82b9c08cf851305523d528
+  metadata.gz: 6ab4fbc86c1ae73dc78bb959fa0038e88dfa60e91b1f7322707c76bc5bd8583a
+  data.tar.gz: '08824b7349988634bc2d0c4ab3e3ad7757d4491e1617c68b44359e42aafacd51'
 SHA512:
-  metadata.gz: 6f915001574717ed1bbadf7f528a6d8d04aa1143cf3ca736db3c1649e72cf4e0d3a60303df86456b6f5ab86a8b1a819987475361a6497f2488f3768ff243dc68
-  data.tar.gz: 865de6b37ea0db45a27852799e2853b37091f32e06e28a405123e429275a05c7591069039f878cf26f6064e0e5d58ad67c9d227ef8911c2092667f009b4610f5
+  metadata.gz: 31d6affbeb9376696c84d6424a55df7dbbab839f37f245da53185ad488a21bbad1871c1ac0f42cddd912388a172af4b7341e3a92287b47622a957b80c9d59061
+  data.tar.gz: 6ead47a3741c1a6d859771b532391dd8aa29f64554884eb042aca67964643c0cfc009662ad5d2939f090ce1b83fa1dff12d004c5ecaee22d5bf538e783b722e3

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [9.5.0](https://github.com/ClosureTree/closure_tree/compare/closure_tree-v9.3.0...closure_tree/v9.5.0) (2026-01-21)
+
+
+### Features
+
+* Add `dependent: :adopt` option for `has_closure_tree` ([#471](https://github.com/ClosureTree/closure_tree/issues/471)) ([d47d7c9](https://github.com/ClosureTree/closure_tree/commit/d47d7c93b59327112a68a7f8454a278877b6ba77))
+* add PostgreSQL schema-qualified table name support ([#462](https://github.com/ClosureTree/closure_tree/issues/462)) ([5f9006c](https://github.com/ClosureTree/closure_tree/commit/5f9006cece95a76f665cb50c2615317e3fa48586))
+* Add runtime advisory lock name customization and multi-database documentation ([#454](https://github.com/ClosureTree/closure_tree/issues/454)) ([d6ffd73](https://github.com/ClosureTree/closure_tree/commit/d6ffd7381e25a28f7a4742bfa2d9c893f0115395))
+* migrate from ActiveSupport::Autoload to Zeitwerk ([#457](https://github.com/ClosureTree/closure_tree/issues/457)) ([d18e80c](https://github.com/ClosureTree/closure_tree/commit/d18e80cdbd4f3510377363bc7b5166f0cc1b0a6f))
+* rewrite with clean api ([#451](https://github.com/ClosureTree/closure_tree/issues/451)) ([f56f2e1](https://github.com/ClosureTree/closure_tree/commit/f56f2e1a3490bb8a099cea8f80b676945fce1c2e))
+* use with_advisory_lock that support rails 8.2 ([#479](https://github.com/ClosureTree/closure_tree/issues/479)) ([bca6231](https://github.com/ClosureTree/closure_tree/commit/bca623168d3255f57e186a3bdcd39e00d38e2a7c))
+
+
+### Bug Fixes
+
+* add implicit_order_column for Rails 8.1+ compatibility ([#464](https://github.com/ClosureTree/closure_tree/issues/464)) ([f384303](https://github.com/ClosureTree/closure_tree/commit/f38430334a79ea15d236f9212118dcb5e4530746))
+* configure release-please to recognize v8.0.0 release ([#455](https://github.com/ClosureTree/closure_tree/issues/455)) ([fc34f21](https://github.com/ClosureTree/closure_tree/commit/fc34f2148570afd83608b07a3f5282e5fd475783))
+* eager loading of hierarchies by defining the primary key ([#465](https://github.com/ClosureTree/closure_tree/issues/465)) ([8c7e490](https://github.com/ClosureTree/closure_tree/commit/8c7e490ff89239e44aee71577288bff0e177a8d6))
+* hierarchy class inheritance to avoid STI validations ([#392](https://github.com/ClosureTree/closure_tree/issues/392)) ([#472](https://github.com/ClosureTree/closure_tree/issues/472)) ([73b07a6](https://github.com/ClosureTree/closure_tree/commit/73b07a6cfeec226af16f51ce7c9c6c1d6d921b3d))
+* improve api usage ([#475](https://github.com/ClosureTree/closure_tree/issues/475)) ([cde4d29](https://github.com/ClosureTree/closure_tree/commit/cde4d292236b4267ac4c0be2e2b21092a8b6298c))
+* nil scope values being excluded from scope filtering ([#476](https://github.com/ClosureTree/closure_tree/issues/476)) ([f45880e](https://github.com/ClosureTree/closure_tree/commit/f45880e9765bfa3c1f171b7386bf5a5584208ad7))
+* restore proper deprecation for database_less configuration ([#459](https://github.com/ClosureTree/closure_tree/issues/459)) ([de8b402](https://github.com/ClosureTree/closure_tree/commit/de8b40233d3de5243afce7ec9de9ad26c2eee181))
+
+## [9.3.0](https://github.com/ClosureTree/closure_tree/compare/closure_tree/v9.2.0...closure_tree/v9.3.0) (2025-11-19)
+
+
+### Features
+
+* eager loading of hierarchies by defining the primary key ([#465](https://github.com/ClosureTree/closure_tree/issues/465)) ([8c7e490](https://github.com/ClosureTree/closure_tree/commit/8c7e490ff89239e44aee71577288bff0e177a8d6))
+
 ## [9.2.0](https://github.com/ClosureTree/closure_tree/compare/closure_tree/v9.1.1...closure_tree/v9.2.0) (2025-10-17)
 
 

data/README.md

@@ -314,11 +314,13 @@ When you include ```has_closure_tree``` in your model, you can provide a hash to
 * ```:hierarchy_table_name``` to override the hierarchy table name. This defaults to the singular name of the model + "_hierarchies", like ```tag_hierarchies```.
 * ```:dependent``` determines what happens when a node is destroyed. Defaults to ```nullify```.
     * ```:nullify``` will simply set the parent column to null. Each child node will be considered a "root" node. This is the default.
+    * ```:adopt``` will move children to their grandparent (parent's parent). If there is no grandparent, children become root nodes. This is useful for maintaining tree structure when removing intermediate nodes.
     * ```:delete_all``` will delete all descendant nodes (which circumvents the destroy hooks)
     * ```:destroy``` will destroy all descendant nodes (which runs the destroy hooks on each child node)
     * ```nil``` does nothing with descendant nodes
 * ```:name_column``` used by #```find_or_create_by_path```, #```find_by_path```, and ```ancestry_path``` instance methods. This is primarily useful if the model only has one required field (like a "tag").
 * ```:order``` used to set up [deterministic ordering](#deterministic-ordering)
+* ```:scope``` restricts root nodes and sibling ordering to specific columns. Can be a single symbol or an array of symbols. Example: ```scope: :user_id``` or ```scope: [:user_id, :group_id]```. This ensures that root nodes and siblings are scoped correctly when reordering. See [Ordering Roots](#ordering-roots) for more details.
 * ```:touch``` delegates to the `belongs_to` annotation for the parent, so `touch`ing cascades to all children (the performance of this for deep trees isn't currently optimal).
 
 ## Accessing Data
@@ -491,9 +493,30 @@ table. So for instance if you have 5 nodes with no parent, they will be ordered
 If your model represents many separate trees and you have a lot of records, this can cause performance
 problems, and doesn't really make much sense.
 
-You can disable this default behavior by passing `dont_order_roots: true` as an option to your delcaration:
+You can scope root nodes and sibling ordering by passing the `scope` option:
 
+```ruby
+class Block < ApplicationRecord
+  has_closure_tree order: 'sort_order', numeric_order: true, scope: :user_id
+end
 ```
+
+This ensures that:
+* Root nodes are scoped by the specified columns. You can filter roots like: ```Block.roots.where(user_id: 123)```
+* Sibling reordering only affects nodes with the same scope values
+* Children reordering respects the parent's scope values
+
+You can also scope by multiple columns:
+
+```ruby
+class Block < ApplicationRecord
+  has_closure_tree order: 'sort_order', numeric_order: true, scope: [:user_id, :group_id]
+end
+```
+
+Alternatively, you can disable root ordering entirely by passing `dont_order_roots: true`:
+
+```ruby
 has_closure_tree order: 'sort_order', numeric_order: true, dont_order_roots: true
 ```
 

data/closure_tree.gemspec

@@ -26,11 +26,11 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 3.3.0'
 
   gem.add_dependency 'activerecord', '>= 7.2.0'
-  gem.add_dependency 'with_advisory_lock', '>= 7.0.0'
+  gem.add_dependency 'with_advisory_lock', '>= 7.5.0'
   gem.add_dependency 'zeitwerk', '~> 2.7'
 
   gem.add_development_dependency 'database_cleaner'
-  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'minitest', '~> 5.0'
   gem.add_development_dependency 'minitest-reporters'
   gem.add_development_dependency 'parallel'
   gem.add_development_dependency 'simplecov'

data/lib/closure_tree/arel_helpers.rb

@@ -79,5 +79,13 @@ module ClosureTree
 
       delete_manager
     end
+
+    # Convert an Arel AST to SQL using the correct connection's visitor
+    # This ensures proper quoting for the specific database adapter (MySQL uses backticks, PostgreSQL uses double quotes)
+    def to_sql_with_connection(arel_manager)
+      collector = Arel::Collectors::SQLString.new
+      visitor = connection.visitor
+      visitor.accept(arel_manager.ast, collector).value
+    end
   end
 end

data/lib/closure_tree/association_setup.rb

@@ -20,7 +20,7 @@ module ClosureTree
 
       has_many :children, *_ct.has_many_order_with_option, class_name: _ct.model_class.to_s,
                                                            foreign_key: _ct.parent_column_name,
-                                                           dependent: _ct.options[:dependent],
+                                                           dependent: _ct.options[:dependent] == :adopt ? :nullify : _ct.options[:dependent],
                                                            inverse_of: :parent do
         # We have to redefine hash_tree because the activerecord relation is already scoped to parent_id.
         def hash_tree(options = {})
@@ -47,4 +47,4 @@ module ClosureTree
                source: :descendant
     end
   end
-end
+end

data/lib/closure_tree/has_closure_tree.rb

@@ -14,7 +14,8 @@ module ClosureTree
         :numeric_order,
         :touch,
         :with_advisory_lock,
-        :advisory_lock_name
+        :advisory_lock_name,
+        :scope
       )
 
       class_attribute :_ct

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -52,12 +52,26 @@ module ClosureTree
 
     def _ct_before_destroy
       _ct.with_advisory_lock do
+        _ct_adopt_children_to_grandparent if _ct.options[:dependent] == :adopt
         delete_hierarchy_references
         self.class.find(id).children.find_each(&:rebuild!) if _ct.options[:dependent] == :nullify
       end
       true # don't prevent destruction
     end
 
+    private def _ct_adopt_children_to_grandparent
+      grandparent_id = read_attribute(_ct.parent_column_name)
+      children_ids = self.class.where(_ct.parent_column_name => id).pluck(:id)
+
+      return if children_ids.empty?
+
+      # Update all children's parent_id in a single query
+      self.class.where(id: children_ids).update_all(_ct.parent_column_name => grandparent_id)
+
+      # Rebuild hierarchy for each child
+      self.class.where(id: children_ids).find_each(&:rebuild!)
+    end
+
     def rebuild!(called_by_rebuild = false)
       _ct.with_advisory_lock do
         delete_hierarchy_references unless (defined? @was_new_record) && @was_new_record
@@ -93,7 +107,7 @@ module ClosureTree
 
         hierarchy_table = hierarchy_class.arel_table
         delete_query = _ct.build_hierarchy_delete_query(hierarchy_table, id)
-        _ct.connection.execute(delete_query.to_sql)
+        _ct.connection.execute(_ct.to_sql_with_connection(delete_query))
       end
     end
 

data/lib/closure_tree/model.rb

@@ -80,7 +80,9 @@ module ClosureTree
     end
 
     def self_and_siblings
-      _ct.scope_with_order(_ct.base_class.where(_ct.parent_column_sym => _ct_parent_id))
+      scope = _ct.base_class.where(_ct.parent_column_sym => _ct_parent_id)
+      scope = _ct.apply_scope_conditions(scope, self)
+      _ct.scope_with_order(scope)
     end
 
     def siblings

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -15,16 +15,19 @@ module ClosureTree
       return unless saved_change_to_attribute?(_ct.parent_column_name) && !@was_new_record
 
       was_parent_id = attribute_before_last_save(_ct.parent_column_name)
-      _ct.reorder_with_parent_id(was_parent_id)
+      scope_conditions = _ct.scope_values_from_instance(self)
+      _ct.reorder_with_parent_id(was_parent_id, nil, scope_conditions)
     end
 
     def _ct_reorder_siblings(minimum_sort_order_value = nil)
-      _ct.reorder_with_parent_id(_ct_parent_id, minimum_sort_order_value)
+      scope_conditions = _ct.scope_values_from_instance(self)
+      _ct.reorder_with_parent_id(_ct_parent_id, minimum_sort_order_value, scope_conditions)
       reload unless destroyed?
     end
 
     def _ct_reorder_children(minimum_sort_order_value = nil)
-      _ct.reorder_with_parent_id(_ct_id, minimum_sort_order_value)
+      scope_conditions = _ct.scope_values_from_instance(self)
+      _ct.reorder_with_parent_id(_ct_id, minimum_sort_order_value, scope_conditions)
     end
 
     def self_and_descendants_preordered

data/lib/closure_tree/numeric_order_support.rb

@@ -14,7 +14,7 @@ module ClosureTree
     end
 
     module MysqlAdapter
-      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, scope_conditions = {})
         return if parent_id.nil? && dont_order_roots
 
         min_where = if minimum_sort_order_value
@@ -22,18 +22,21 @@ module ClosureTree
                     else
                       ''
                     end
+
+        scope_where = build_scope_where_clause(scope_conditions)
+
         connection.execute 'SET @i = 0'
         connection.execute <<-SQL.squish
           UPDATE #{quoted_table_name}
             SET #{quoted_order_column} = (@i := @i + 1) + #{minimum_sort_order_value.to_i - 1}
-          WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}
+          WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}#{scope_where}
           ORDER BY #{nulls_last_order_by}
         SQL
       end
     end
 
     module PostgreSQLAdapter
-      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, scope_conditions = {})
         return if parent_id.nil? && dont_order_roots
 
         min_where = if minimum_sort_order_value
@@ -41,13 +44,16 @@ module ClosureTree
                     else
                       ''
                     end
+
+        scope_where = build_scope_where_clause(scope_conditions)
+
         connection.execute <<-SQL.squish
           UPDATE #{quoted_table_name}
           SET #{quoted_order_column(false)} = t.seq + #{minimum_sort_order_value.to_i - 1}
           FROM (
             SELECT #{quoted_id_column_name} AS id, row_number() OVER(ORDER BY #{order_by}) AS seq
             FROM #{quoted_table_name}
-            WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}
+            WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}#{scope_where}
           ) AS t
           WHERE #{quoted_table_name}.#{quoted_id_column_name} = t.id and
                 #{quoted_table_name}.#{quoted_order_column(false)} is distinct from t.seq + #{minimum_sort_order_value.to_i - 1}
@@ -60,12 +66,13 @@ module ClosureTree
     end
 
     module GenericAdapter
-      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, scope_conditions = {})
         return if parent_id.nil? && dont_order_roots
 
         scope = model_class
                 .where(parent_column_sym => parent_id)
                 .order(nulls_last_order_by)
+        scope = scope.where(scope_conditions) if scope_conditions.any?
         scope = scope.where("#{quoted_order_column} >= #{minimum_sort_order_value}") if minimum_sort_order_value
         scope.each_with_index do |ea, idx|
           ea.update_order_value(idx + minimum_sort_order_value.to_i)

data/lib/closure_tree/support.rb

@@ -16,26 +16,53 @@ module ClosureTree
 
       @options = {
         parent_column_name: 'parent_id',
-        dependent: :nullify, # or :destroy or :delete_all -- see the README
+        dependent: :nullify, # or :destroy, :delete_all, or :adopt -- see the README
         name_column: 'name',
         with_advisory_lock: true, # This will be overridden by adapter support
         numeric_order: false
       }.merge(options)
       raise ArgumentError, "name_column can't be 'path'" if options[:name_column] == 'path'
 
+      if options[:scope]
+        scope_option = options[:scope]
+        unless scope_option.is_a?(Symbol) || (scope_option.is_a?(Array) && scope_option.all? { |item| item.is_a?(Symbol) })
+          raise ArgumentError, "scope option must be a Symbol or an Array of Symbols (e.g., :user_id or [:user_id, :group_id])"
+        end
+      end
+
       return unless order_is_numeric?
 
       extend NumericOrderSupport.adapter_for_connection(connection)
     end
 
+    # Find the abstract base class for database connection
+    # This ensures hierarchy class uses the same database but doesn't inherit
+    # validations/callbacks from STI parent classes (issue #392)
+    def abstract_base_class
+      klass = model_class
+      while klass.superclass != ActiveRecord::Base
+        parent = klass.superclass
+        # Stop at abstract class (ApplicationRecord, SecondaryRecord, etc.)
+        return parent if parent.abstract_class?
+        # Stop at connection boundary (handles non-abstract parents with custom connections)
+        return parent if parent.connection_specification_name != parent.superclass.connection_specification_name
+        klass = parent
+      end
+      ActiveRecord::Base
+    end
+
     def hierarchy_class_for_model
       parent_class = model_class.module_parent
-      hierarchy_class = parent_class.const_set(short_hierarchy_class_name, Class.new(model_class.superclass))
+      hierarchy_class = parent_class.const_set(short_hierarchy_class_name, Class.new(abstract_base_class))
       model_class_name = model_class.to_s
       hierarchy_class.class_eval do
         # Rails 8.1+ requires an implicit_order_column for models without a primary key
         self.implicit_order_column = 'ancestor_id'
 
+        # Rails uses the primary key to correctly match associations when using a join to preload (e.g. via `eager_load`).
+        # The migration generator adds a unique index across these three columns so this is safe.
+        self.primary_key = [:ancestor_id, :descendant_id, :generations]
+
         belongs_to :ancestor, class_name: model_class_name
         belongs_to :descendant, class_name: model_class_name
         def ==(other)
@@ -109,6 +136,22 @@ module ClosureTree
       end
     end
 
+    # Builds SQL WHERE conditions for scope columns
+    # Returns a string that can be appended to a WHERE clause
+    def build_scope_where_clause(scope_conditions)
+      return '' unless scope_conditions.is_a?(Hash) && scope_conditions.any?
+
+      conditions = scope_conditions.map do |column, value|
+        if value.nil?
+          "#{connection.quote_column_name(column.to_s)} IS NULL"
+        else
+          "#{connection.quote_column_name(column.to_s)} = #{quoted_value(value)}"
+        end
+      end
+
+      " AND #{conditions.join(' AND ')}"
+    end
+
     def with_advisory_lock(&block)
       if options[:with_advisory_lock] && connection.supports_advisory_locks? && model_class.respond_to?(:with_advisory_lock)
         model_class.with_advisory_lock(advisory_lock_name) do
@@ -170,5 +213,49 @@ module ClosureTree
     def create!(model_class, attributes)
       create(model_class, attributes).tap(&:save!)
     end
+
+    def scope_columns
+      return [] unless options[:scope]
+
+      scope_option = options[:scope]
+
+      case scope_option
+      when Symbol
+        [scope_option]
+      when Array
+        scope_option.select { |item| item.is_a?(Symbol) }
+      else
+        []
+      end
+    end
+
+    def scope_values_from_instance(instance)
+      return {} unless options[:scope] && instance
+
+      scope_option = options[:scope]
+      scope_hash = {}
+
+      case scope_option
+      when Symbol
+        value = instance.read_attribute(scope_option)
+        scope_hash[scope_option] = value
+      when Array
+        scope_option.each do |item|
+          if item.is_a?(Symbol)
+            value = instance.read_attribute(item)
+            scope_hash[item] = value
+          end
+        end
+      end
+
+      scope_hash
+    end
+
+    def apply_scope_conditions(scope, instance = nil)
+      return scope unless options[:scope] && instance
+
+      scope_values = scope_values_from_instance(instance)
+      scope_values.any? ? scope.where(scope_values) : scope
+    end
   end
 end

data/lib/closure_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClosureTree
-  VERSION = Gem::Version.new('9.2.0')
+  VERSION = Gem::Version.new('9.5.0')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 9.2.0
+  version: 9.5.0
 platform: ruby
 authors:
 - Matthew McEachen
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.5.0
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +70,16 @@ dependencies:
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -178,7 +178,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/ClosureTree/closure_tree/issues
   changelog_uri: https://github.com/ClosureTree/closure_tree/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/closure_tree/9.2.0
+  documentation_uri: https://www.rubydoc.info/gems/closure_tree/9.5.0
   homepage_uri: https://closuretree.github.io/closure_tree/
   source_code_uri: https://github.com/ClosureTree/closure_tree
   rubygems_mfa_required: 'true'