From 3b507bb281258b9cf32fae937c9cb07dce5a28d2 Mon Sep 17 00:00:00 2001
From: Abdelkader Boudih <terminale@gmail.com>
Date: Thu, 24 Jul 2025 10:02:00 +0100
Subject: [PATCH] fix: restore proper deprecation for database_less
 configuration

The database_less configuration option was removed in v9.1.0 without proper
deprecation, causing deployments to fail when upgrading if they had this
configuration in their production.rb or initializers.

This change restores backward compatibility by:

- Adding a minimal Configuration class that captures the deprecated database_less option
- Showing specific deprecation warnings when database_less is used
- Making the option a no-op (always returns false) since it's no longer needed
- Providing clear migration guidance for users to remove their configuration

The deprecation timeline indicates removal in v10.0.0, giving users time to
migrate away from this obsolete configuration without breaking deployments.

Also includes improvements to HasClosureTree include order dependency and
README formatting fixes to use inline return value comments.

Fixes the missing deprecation that was introduced when migrating to Zeitwerk.
---
 README.md                             | 39 ++++++++-------------
 lib/closure_tree.rb                   | 15 +++++---
 lib/closure_tree/association_setup.rb | 50 +++++++++++++++++++++++++++
 lib/closure_tree/configuration.rb     | 22 ++++++++++++
 lib/closure_tree/has_closure_tree.rb  |  9 +++--
 lib/closure_tree/model.rb             | 39 ---------------------
 6 files changed, 104 insertions(+), 70 deletions(-)
 create mode 100644 lib/closure_tree/association_setup.rb
 create mode 100644 lib/closure_tree/configuration.rb

diff --git a/README.md b/README.md
index 16a86ba..89c7d05 100644
--- a/README.md
+++ b/README.md
@@ -73,6 +73,8 @@ Note that closure_tree only supports ActiveRecord 7.2 and later, and has test co
 
     Make sure you check out the [large number of options](#available-options) that `has_closure_tree` accepts.
 
+    **Note:** The `acts_as_tree` alias is only created if your model doesn't already have a method with that name. This prevents conflicts with other gems like the original `acts_as_tree` gem.
+
     **IMPORTANT: Make sure you add `has_closure_tree` _after_ `attr_accessible` and
     `self.table_name =` lines in your model.**
 
@@ -156,10 +158,10 @@ Then:
 
 ```ruby
 grandparent.self_and_descendants.collect(&:name)
-=> ["Grandparent", "Parent", "First Child", "Second Child", "Third Child", "Fourth Child"]
+#=> ["Grandparent", "Parent", "First Child", "Second Child", "Third Child", "Fourth Child"]
 
 child1.ancestry_path
-=> ["Grandparent", "Parent", "First Child"]
+#=> ["Grandparent", "Parent", "First Child"]
 ```
 
 ### find_or_create_by_path
@@ -204,19 +206,16 @@ d = Tag.find_or_create_by_path %w[a b c d]
 h = Tag.find_or_create_by_path %w[e f g h]
 e = h.root
 d.add_child(e) # "d.children << e" would work too, of course
-h.ancestry_path
-=> ["a", "b", "c", "d", "e", "f", "g", "h"]
+h.ancestry_path #=> ["a", "b", "c", "d", "e", "f", "g", "h"]
 ```
 
 When it is more convenient to simply change the `parent_id` of a node directly (for example, when dealing with a form `<select>`), closure_tree will handle the necessary changes automatically when the record is saved:
 
 ```ruby
 j = Tag.find 102
-j.self_and_ancestor_ids
-=> [102, 87, 77]
+j.self_and_ancestor_ids #=> [102, 87, 77]
 j.update parent_id: 96
-j.self_and_ancestor_ids
-=> [102, 96, 95, 78]
+j.self_and_ancestor_ids #=> [102, 96, 95, 78]
 ```
 
 ### Nested hashes
@@ -233,17 +232,13 @@ c1 = d1.parent
 d2 = b.find_or_create_by_path %w(c2 d2)
 c2 = d2.parent
 
-Tag.hash_tree
-=> {a => {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}, b2 => {}}}
+Tag.hash_tree #=> {a => {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}, b2 => {}}}
 
-Tag.hash_tree(:limit_depth => 2)
-=> {a => {b => {}, b2 => {}}}
+Tag.hash_tree(:limit_depth => 2) #=> {a => {b => {}, b2 => {}}}
 
-b.hash_tree
-=> {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}}
+b.hash_tree #=> {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}}
 
-b.hash_tree(:limit_depth => 2)
-=> {b => {c1 => {}, c2 => {}}}
+b.hash_tree(:limit_depth => 2) #=> {b => {c1 => {}, c2 => {}}}
 ```
 
 **If your tree is large (or might become so), use :limit_depth.**
@@ -477,20 +472,16 @@ c = OrderedTag.create(name: 'c')
 # We have to call 'root.reload.children' because root won't be in sync with the database otherwise:
 
 a.append_sibling(b)
-root.reload.children.pluck(:name)
-=> ["a", "b"]
+root.reload.children.pluck(:name) #=> ["a", "b"]
 
 a.prepend_sibling(b)
-root.reload.children.pluck(:name)
-=> ["b", "a"]
+root.reload.children.pluck(:name) #=> ["b", "a"]
 
 a.append_sibling(c)
-root.reload.children.pluck(:name)
-=> ["b", "a", "c"]
+root.reload.children.pluck(:name) #=> ["b", "a", "c"]
 
 b.append_sibling(c)
-root.reload.children.pluck(:name)
-=> ["b", "c", "a"]
+root.reload.children.pluck(:name) #=> ["b", "c", "a"]
 ```
 
 ### Ordering Roots
diff --git a/lib/closure_tree.rb b/lib/closure_tree.rb
index 728ee79..5bfcbc5 100644
--- a/lib/closure_tree.rb
+++ b/lib/closure_tree.rb
@@ -9,11 +9,16 @@
 
 module ClosureTree
   def self.configure
-    ActiveSupport::Deprecation.new.warn(
-      'ClosureTree.configure is deprecated and will be removed in a future version. ' \
-      'Configuration is no longer needed.'
-    )
-    yield if block_given?
+    if block_given?
+      # Create a temporary configuration object to capture deprecated settings
+      config = Configuration.new
+      yield config
+    else
+      ActiveSupport::Deprecation.new.warn(
+        'ClosureTree.configure is deprecated and will be removed in a future version. ' \
+        'Configuration is no longer needed.'
+      )
+    end
   end
 end
 
diff --git a/lib/closure_tree/association_setup.rb b/lib/closure_tree/association_setup.rb
new file mode 100644
index 0000000..3b5a379
--- /dev/null
+++ b/lib/closure_tree/association_setup.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ClosureTree
+  # This concern sets up the ActiveRecord associations after all other modules are included.
+  # It must be included last to ensure that HierarchyMaintenance callbacks are already set up.
+  module AssociationSetup
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :parent, nil,
+                 class_name: _ct.model_class.to_s,
+                 foreign_key: _ct.parent_column_name,
+                 inverse_of: :children,
+                 touch: _ct.options[:touch],
+                 optional: true
+
+      order_by_generations = -> { Arel.sql("#{_ct.quoted_hierarchy_table_name}.generations ASC") }
+
+      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],
+                                                           inverse_of: :parent do
+        # We have to redefine hash_tree because the activerecord relation is already scoped to parent_id.
+        def hash_tree(options = {})
+          # we want limit_depth + 1 because we don't do self_and_descendants.
+          limit_depth = options[:limit_depth]
+          _ct.hash_tree(@association.owner.descendants, limit_depth ? limit_depth + 1 : nil)
+        end
+      end
+
+      has_many :ancestor_hierarchies, *_ct.has_many_order_without_option(order_by_generations),
+               class_name: _ct.hierarchy_class_name,
+               foreign_key: 'descendant_id'
+
+      has_many :self_and_ancestors, *_ct.has_many_order_without_option(order_by_generations),
+               through: :ancestor_hierarchies,
+               source: :ancestor
+
+      has_many :descendant_hierarchies, *_ct.has_many_order_without_option(order_by_generations),
+               class_name: _ct.hierarchy_class_name,
+               foreign_key: 'ancestor_id'
+
+      has_many :self_and_descendants, *_ct.has_many_order_with_option(order_by_generations),
+               through: :descendant_hierarchies,
+               source: :descendant
+    end
+  end
+end
\ No newline at end of file
diff --git a/lib/closure_tree/configuration.rb b/lib/closure_tree/configuration.rb
new file mode 100644
index 0000000..b81bc4d
--- /dev/null
+++ b/lib/closure_tree/configuration.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ClosureTree
+  # Minimal configuration class to handle deprecated options
+  class Configuration
+    def database_less=(_value)
+      ActiveSupport::Deprecation.new.warn(
+        'ClosureTree.configure { |config| config.database_less = true } is deprecated ' \
+        'and will be removed in v10.0.0. The database_less option is no longer needed ' \
+        'for modern deployment practices. Remove this configuration from your initializer.'
+      )
+      # Ignore the value - this is a no-op for backward compatibility
+    end
+
+    def database_less?
+      false # Always return false since this option does nothing
+    end
+
+    # Keep the old method name for backward compatibility
+    alias database_less database_less?
+  end
+end
diff --git a/lib/closure_tree/has_closure_tree.rb b/lib/closure_tree/has_closure_tree.rb
index ee6db3a..5550cc7 100644
--- a/lib/closure_tree/has_closure_tree.rb
+++ b/lib/closure_tree/has_closure_tree.rb
@@ -25,7 +25,8 @@ def has_closure_tree(options = {})
       class_attribute :hierarchy_class
       self.hierarchy_class = _ct.hierarchy_class_for_model
 
-      # tests fail if you include Model before HierarchyMaintenance wtf
+      # Include modules - HierarchyMaintenance provides callbacks that Model associations depend on
+      # The order is maintained for consistency, but associations are now set up after all includes
       include ClosureTree::HierarchyMaintenance
       include ClosureTree::Model
       include ClosureTree::Finders
@@ -35,9 +36,13 @@ def has_closure_tree(options = {})
       include ClosureTree::DeterministicOrdering if _ct.order_option?
       include ClosureTree::NumericDeterministicOrdering if _ct.order_is_numeric?
 
+      # Include AssociationSetup last to ensure all dependencies are ready
+      include ClosureTree::AssociationSetup
+
       connection_pool.release_connection
     end
 
-    alias acts_as_tree has_closure_tree
+    # Only alias acts_as_tree if it's not already defined (to avoid conflicts with other gems)
+    alias acts_as_tree has_closure_tree unless method_defined?(:acts_as_tree)
   end
 end
diff --git a/lib/closure_tree/model.rb b/lib/closure_tree/model.rb
index dee315c..98ba50f 100644
--- a/lib/closure_tree/model.rb
+++ b/lib/closure_tree/model.rb
@@ -6,45 +6,6 @@ module ClosureTree
   module Model
     extend ActiveSupport::Concern
 
-    included do
-      belongs_to :parent, nil,
-                 class_name: _ct.model_class.to_s,
-                 foreign_key: _ct.parent_column_name,
-                 inverse_of: :children,
-                 touch: _ct.options[:touch],
-                 optional: true
-
-      order_by_generations = -> { Arel.sql("#{_ct.quoted_hierarchy_table_name}.generations ASC") }
-
-      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],
-                                                           inverse_of: :parent do
-        # We have to redefine hash_tree because the activerecord relation is already scoped to parent_id.
-        def hash_tree(options = {})
-          # we want limit_depth + 1 because we don't do self_and_descendants.
-          limit_depth = options[:limit_depth]
-          _ct.hash_tree(@association.owner.descendants, limit_depth ? limit_depth + 1 : nil)
-        end
-      end
-
-      has_many :ancestor_hierarchies, *_ct.has_many_order_without_option(order_by_generations),
-               class_name: _ct.hierarchy_class_name,
-               foreign_key: 'descendant_id'
-
-      has_many :self_and_ancestors, *_ct.has_many_order_without_option(order_by_generations),
-               through: :ancestor_hierarchies,
-               source: :ancestor
-
-      has_many :descendant_hierarchies, *_ct.has_many_order_without_option(order_by_generations),
-               class_name: _ct.hierarchy_class_name,
-               foreign_key: 'ancestor_id'
-
-      has_many :self_and_descendants, *_ct.has_many_order_with_option(order_by_generations),
-               through: :descendant_hierarchies,
-               source: :descendant
-    end
-
     # Delegate to the Support instance on the class:
     def _ct
       self.class._ct