closure_tree 9.3.0 → 9.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7af281d62397e19768240a93ab284f2ceb9b261f5c4c3d2ac7d288300212b6e
-  data.tar.gz: ef0cf220eb02fcfafb17034265ee6d3ceb514c13898bf8c71eab1915f2a156c6
+  metadata.gz: 8e3f99ea82d4fd195ea034a9f6fcfdd0ce1ec69e74fa2b62241b68eb74070676
+  data.tar.gz: b59d11e3fe4e6236c457776b5b5e7cc7133c77759789fbe816b8185db44855e8
 SHA512:
-  metadata.gz: 0a04211a36264ac886ecb8b7260c23e767de8364725fdc39dbfbe508116a5201ec8a54f4edf1865b3b91c8ee0fca4d2152d7f1091fca056501995723e4edbce6
-  data.tar.gz: d0ac8d6a477e357ff6582079443b6221100d868e1234d7aaaa4a815108b0db2e024e84086e2ace0c3dc3d1b85b8cd40701737f4bc292dabf479ca6263bccd994
+  metadata.gz: 2a1d3b69d8397b4f5d8b8ad7e81df74e9577c77dcbd10851b5fdc00a17f2b0b5caee0446fe71b3aaec28d0b79c7a4b8d97a89edcd3ac4599bbbeb4b0d6ddeb21
+  data.tar.gz: 88d92d332638b6c38e6575ae14ebfd8ec060c2ef0137f7335b72bda4f84537d7db43032623ac5138d31424753cbf83208e5f7f4de0ce1953fcd03a0d8314fbeb

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [9.6.0](https://github.com/ClosureTree/closure_tree/compare/closure_tree/v9.5.0...closure_tree/v9.6.0) (2026-02-16)
+
+
+### Features
+
+* raise error when advisory lock cannot be acquired within configured timeout ([#480](https://github.com/ClosureTree/closure_tree/issues/480)) ([c030385](https://github.com/ClosureTree/closure_tree/commit/c030385297a9d3042d43354676a794b1c5757d2a))
+* sibling reordering when node changes parent or scope ([#484](https://github.com/ClosureTree/closure_tree/issues/484)) ([254ba36](https://github.com/ClosureTree/closure_tree/commit/254ba360638bf21717d214b7fd328db8ffa167e0))
+
+## [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)
 
 

data/README.md

@@ -314,6 +314,7 @@ 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
@@ -321,6 +322,7 @@ When you include ```has_closure_tree``` in your model, you can provide a hash to
 * ```: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).
+* ```:advisory_lock_timeout_seconds``` When set, the advisory lock will raise ```WithAdvisoryLock::FailedToAcquireLock``` if the lock cannot be acquired within the timeout period. This helps callers handle timeout scenarios (e.g. retry or fail fast). If the option is not specified, the lock is waited for indefinitely until it is acquired. See [Lock wait timeouts](https://github.com/ClosureTree/with_advisory_lock?tab=readme-ov-file#lock-wait-timeouts) in the with_advisory_lock gem for details.
 
 ## Accessing Data
 

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

@@ -15,6 +15,7 @@ module ClosureTree
         :touch,
         :with_advisory_lock,
         :advisory_lock_name,
+        :advisory_lock_timeout_seconds,
         :scope
       )
 

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -18,7 +18,10 @@ module ClosureTree
     end
 
     def _ct_skip_sort_order_maintenance!
-      @_ct_skip_sort_order_maintenance = true
+      ActiveSupport::Deprecation.new.warn(
+        '_ct_skip_sort_order_maintenance! is deprecated and will be removed in the next major version. ' \
+        'Sort order maintenance is now handled automatically.'
+      )
     end
 
     def _ct_validate
@@ -38,7 +41,17 @@ module ClosureTree
     end
 
     def _ct_after_save
-      rebuild! if saved_changes[_ct.parent_column_name] || @was_new_record
+      scope_changed = _ct.order_is_numeric? && _ct.scope_changed?(self)
+
+      if saved_changes[_ct.parent_column_name] || @was_new_record
+        rebuild!
+      elsif scope_changed
+        # Scope changed without parent change - reorder old scope's siblings
+        _ct_reorder_prior_siblings_if_parent_changed
+        _ct_reorder_siblings
+      elsif _ct.order_option? && saved_changes[_ct.order_column_sym]
+        _ct_reorder_siblings(saved_changes[_ct.order_column_sym].min)
+      end
       if saved_changes[_ct.parent_column_name] && !@was_new_record
         # Resetting the ancestral collections addresses
         # https://github.com/mceachen/closure_tree/issues/68
@@ -46,18 +59,31 @@ module ClosureTree
         self_and_ancestors.reload
       end
       @was_new_record = false # we aren't new anymore.
-      @_ct_skip_sort_order_maintenance = false # only skip once.
       true # don't cancel anything.
     end
 
     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
@@ -72,7 +98,7 @@ module ClosureTree
           SQL
         end
 
-        if _ct.order_is_numeric? && !@_ct_skip_sort_order_maintenance
+        if _ct.order_is_numeric?
           _ct_reorder_prior_siblings_if_parent_changed
           # Prevent double-reordering of siblings:
           _ct_reorder_siblings unless called_by_rebuild
@@ -93,7 +119,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/numeric_deterministic_ordering.rb

@@ -12,11 +12,16 @@ module ClosureTree
     end
 
     def _ct_reorder_prior_siblings_if_parent_changed
-      return unless saved_change_to_attribute?(_ct.parent_column_name) && !@was_new_record
+      return if @was_new_record
+
+      parent_changed = saved_change_to_attribute?(_ct.parent_column_name)
+      scope_changed = _ct.scope_changed?(self)
+
+      return unless parent_changed || scope_changed
 
       was_parent_id = attribute_before_last_save(_ct.parent_column_name)
-      scope_conditions = _ct.scope_values_from_instance(self)
-      _ct.reorder_with_parent_id(was_parent_id, nil, scope_conditions)
+      previous_scope_conditions = _ct.previous_scope_values_from_instance(self)
+      _ct.reorder_with_parent_id(was_parent_id, nil, previous_scope_conditions)
     end
 
     def _ct_reorder_siblings(minimum_sort_order_value = nil)
@@ -132,9 +137,7 @@ module ClosureTree
     def prepend_child(child_node)
       child_node.order_value = -1
       child_node.parent = self
-      child_node._ct_skip_sort_order_maintenance!
       if child_node.save
-        _ct_reorder_children
         child_node.reload
       else
         child_node
@@ -161,19 +164,11 @@ module ClosureTree
 
       _ct.with_advisory_lock do
         prior_sibling_parent = sibling.parent
-        reorder_from_value = if prior_sibling_parent == parent
-                               [order_value, sibling.order_value].compact.min
-                             else
-                               order_value
-                             end
 
         sibling.order_value = order_value
         sibling.parent = parent
-        sibling._ct_skip_sort_order_maintenance!
         sibling.save # may be a no-op
 
-        _ct_reorder_siblings(reorder_from_value)
-
         # The sort order should be correct now except for self and sibling, which may need to flip:
         sibling_is_after = reload.order_value < sibling.reload.order_value
         if add_after != sibling_is_after

data/lib/closure_tree/support.rb

@@ -16,9 +16,10 @@ 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
+        advisory_lock_timeout_seconds: nil,
         numeric_order: false
       }.merge(options)
       raise ArgumentError, "name_column can't be 'path'" if options[:name_column] == 'path'
@@ -30,14 +31,34 @@ module ClosureTree
         end
       end
 
+      if !@options[:with_advisory_lock] && @options[:advisory_lock_timeout_seconds].present?
+        raise ArgumentError, "advisory_lock_timeout_seconds can't be specified when advisory_lock is disabled"
+      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
@@ -137,8 +158,9 @@ module ClosureTree
     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
+      lock_method = options[:advisory_lock_timeout_seconds].present? ? :with_advisory_lock! : :with_advisory_lock
+      if options[:with_advisory_lock] && connection.supports_advisory_locks? && model_class.respond_to?(lock_method)
+        model_class.public_send(lock_method, advisory_lock_name, advisory_lock_options) do
           transaction(&block)
         end
       else
@@ -222,12 +244,12 @@ module ClosureTree
       case scope_option
       when Symbol
         value = instance.read_attribute(scope_option)
-        scope_hash[scope_option] = value unless value.nil?
+        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 unless value.nil?
+            scope_hash[item] = value
           end
         end
       end
@@ -235,6 +257,45 @@ module ClosureTree
       scope_hash
     end
 
+    def previous_scope_values_from_instance(instance)
+      return {} unless options[:scope] && instance
+
+      scope_option = options[:scope]
+      scope_hash = {}
+
+      case scope_option
+      when Symbol
+        value = instance.attribute_before_last_save(scope_option)
+        scope_hash[scope_option] = value
+      when Array
+        scope_option.each do |item|
+          if item.is_a?(Symbol)
+            value = instance.attribute_before_last_save(item)
+            scope_hash[item] = value
+          end
+        end
+      end
+
+      scope_hash
+    end
+
+    def scope_changed?(instance)
+      return false unless options[:scope] && instance
+
+      scope_option = options[:scope]
+
+      case scope_option
+      when Symbol
+        instance.saved_change_to_attribute?(scope_option)
+      when Array
+        scope_option.any? do |item|
+          item.is_a?(Symbol) && instance.saved_change_to_attribute?(item)
+        end
+      else
+        false
+      end
+    end
+
     def apply_scope_conditions(scope, instance = nil)
       return scope unless options[:scope] && instance
 

data/lib/closure_tree/support_attributes.rb

@@ -34,6 +34,10 @@ module ClosureTree
       end
     end
 
+    def advisory_lock_options
+      { timeout_seconds: options[:advisory_lock_timeout_seconds] }.compact
+    end
+
     def quoted_table_name
       connection.quote_table_name(table_name)
     end

data/lib/closure_tree/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 9.3.0
+  version: 9.6.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.3.0
+  documentation_uri: https://www.rubydoc.info/gems/closure_tree/9.6.0
   homepage_uri: https://closuretree.github.io/closure_tree/
   source_code_uri: https://github.com/ClosureTree/closure_tree
   rubygems_mfa_required: 'true'