closure_tree 8.0.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1833e9f0cef7b45722dc67fcea625de8ee04bd820de6567da77f5f7bf3a97e65
-  data.tar.gz: 6c0c050d6b081b612b11d76c2e79b1f84f56dade7ad3b6f2b445f9bfa3d90d1d
+  metadata.gz: 7da1033357e368c9a4d2a36b95a8e75899b61b63e872c25167dd5f8862afb454
+  data.tar.gz: '08df010ac42f946d8171152ad5ef4a8e6c1b94263cf39e5d297e4cbf805dca81'
 SHA512:
-  metadata.gz: 3d61b4e41fd71552f54aba6bfec350fc75d5a923797c580fe2d7e48df6e7f3917477f7992c6bd9d59b614730f9978c77acd100ee4d848d737afb42e3e629dcf6
-  data.tar.gz: ed181080ce63b08712cbd8981cfa057cb4c432ed228cff8dac22a3770f9d41d7a81adff3b3b251bffb710e030952d6fe570e767707c835d72cbb0915ec328008
+  metadata.gz: 34ef107ba1737f7e4cec6ff581149ce66b4daed0dee6b0e4bc266688a748c182e8c4e1082d38846de22671a23b2a640d80f753715f8e93fdc7889d134cd14c97
+  data.tar.gz: 300a2a3b499a8428e23f89235e409dce6cbd50378ee6406f2ab03d03b97f63d20b5365ff9adabbfaff47ce9b50a54fd5a2e80576dd5839b7d23debce98528074

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [9.0.0](https://github.com/ClosureTree/closure_tree/compare/closure_tree-v8.0.0...closure_tree/v9.0.0) (2025-07-21)
+
+
+### Features
+
+* 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))
+* rewrite with clean api ([#451](https://github.com/ClosureTree/closure_tree/issues/451)) ([f56f2e1](https://github.com/ClosureTree/closure_tree/commit/f56f2e1a3490bb8a099cea8f80b676945fce1c2e))
+
+
+### Bug Fixes
+
+* 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))
+
 ### 8.0.0
 
 - Drop support to EOL ruby and rails

data/README.md

@@ -24,7 +24,7 @@ closure_tree has some great features:
   * 2 SQL INSERTs on node creation
   * 3 SQL INSERT/UPDATEs on node reparenting
 * __Support for [concurrency](#concurrency)__ (using [with_advisory_lock](https://github.com/ClosureTree/with_advisory_lock))
-* __Tested against ActiveRecord 7.1+ with Ruby 3.3+__
+* __Tested against ActiveRecord 7.2+ with Ruby 3.3+__
 * Support for reparenting children (and all their descendants)
 * Support for [single-table inheritance (STI)](#sti) within the hierarchy
 * ```find_or_create_by_path``` for [building out heterogeneous hierarchies quickly and conveniently](#find_or_create_by_path)
@@ -46,13 +46,14 @@ for a description of different tree storage algorithms.
 - [Polymorphic hierarchies with STI](#polymorphic-hierarchies-with-sti)
 - [Deterministic ordering](#deterministic-ordering)
 - [Concurrency](#concurrency)
+- [Multi-Database Support](#multi-database-support)
 - [FAQ](#faq)
 - [Testing](#testing)
 - [Change log](#change-log)
 
 ## Installation
 
-Note that closure_tree only supports ActiveRecord 7.1 and later, and has test coverage for MySQL, PostgreSQL, and SQLite.
+Note that closure_tree only supports ActiveRecord 7.2 and later, and has test coverage for MySQL, PostgreSQL, and SQLite.
 
 1.  Add `gem 'closure_tree'` to your Gemfile
 
@@ -61,11 +62,11 @@ Note that closure_tree only supports ActiveRecord 7.1 and later, and has test co
 3.  Add `has_closure_tree` (or `acts_as_tree`, which is an alias of the same method) to your hierarchical model:
 
     ```ruby
-    class Tag < ActiveRecord::Base
+    class Tag < ApplicationRecord
       has_closure_tree
     end
 
-    class AnotherTag < ActiveRecord::Base
+    class AnotherTag < ApplicationRecord
       acts_as_tree
     end
     ```
@@ -82,7 +83,7 @@ Note that closure_tree only supports ActiveRecord 7.1 and later, and has test co
     You may want to also [add a column for deterministic ordering of children](#deterministic-ordering), but that's optional.
 
     ```ruby
-    class AddParentIdToTag < ActiveRecord::Migration
+    class AddParentIdToTag < ActiveRecord::Migration[7.2]
       def change
         add_column :tags, :parent_id, :integer
       end
@@ -384,7 +385,7 @@ Polymorphic models using single table inheritance (STI) are supported:
 2. Subclass the model class. You only need to add ```has_closure_tree``` to your base class:
 
 ```ruby
-class Tag < ActiveRecord::Base
+class Tag < ApplicationRecord
   has_closure_tree
 end
 class WhenTag < Tag ; end
@@ -411,7 +412,7 @@ By default, children will be ordered by your database engine, which may not be w
 If you want to order children alphabetically, and your model has a ```name``` column, you'd do this:
 
 ```ruby
-class Tag < ActiveRecord::Base
+class Tag < ApplicationRecord
   has_closure_tree order: 'name'
 end
 ```
@@ -425,7 +426,7 @@ t.integer :sort_order
 and in your model:
 
 ```ruby
-class OrderedTag < ActiveRecord::Base
+class OrderedTag < ApplicationRecord
   has_closure_tree order: 'sort_order', numeric_order: true
 end
 ```
@@ -525,7 +526,7 @@ If you are already managing concurrency elsewhere in your application, and want
 of with_advisory_lock, pass ```with_advisory_lock: false``` in the options hash:
 
 ```ruby
-class Tag
+class Tag < ApplicationRecord
   has_closure_tree with_advisory_lock: false
 end
 ```
@@ -533,6 +534,98 @@ end
 Note that you *will eventually have data corruption* if you disable advisory locks, write to your
 database with multiple threads, and don't provide an alternative mutex.
 
+### Customizing Advisory Lock Names
+
+By default, closure_tree generates advisory lock names based on the model class name. You can customize
+this behavior in several ways:
+
+```ruby
+# Static string
+class Tag < ApplicationRecord
+  has_closure_tree advisory_lock_name: 'custom_tag_lock'
+end
+
+# Dynamic via Proc
+class Tag < ApplicationRecord
+  has_closure_tree advisory_lock_name: ->(model_class) { "#{Rails.env}_#{model_class.name.underscore}" }
+end
+
+# Delegate to model method
+class Tag < ApplicationRecord
+  has_closure_tree advisory_lock_name: :custom_lock_name
+  
+  def self.custom_lock_name
+    "tag_lock_#{current_tenant_id}"
+  end
+end
+```
+
+This is particularly useful when:
+* You need environment-specific lock names
+* You're using multi-tenancy and need tenant-specific locks
+* You want to avoid lock name collisions between similar model names
+
+## Multi-Database Support
+
+Closure Tree fully supports running with multiple databases simultaneously, including mixing different database engines (PostgreSQL, MySQL, SQLite) in the same application. This is particularly useful for:
+
+* Applications with read replicas
+* Sharding strategies
+* Testing with different database engines
+* Gradual database migrations
+
+### Database-Specific Behaviors
+
+#### PostgreSQL
+* Full support for advisory locks via `with_advisory_lock`
+* Excellent concurrency support with row-level locking
+* Best overall performance for tree operations
+
+#### MySQL
+* Advisory locks supported via `with_advisory_lock`
+* Note: MySQL's row-level locking may incorrectly report deadlocks in some cases
+* Requires MySQL 5.7.12+ to avoid hierarchy maintenance errors
+
+#### SQLite
+* **No advisory lock support** - always returns false from `with_advisory_lock`
+* Falls back to file-based locking for tests
+* Suitable for development and testing, but not recommended for production with concurrent writes
+
+### Configuration
+
+When using multiple databases, closure_tree automatically detects the correct adapter for each connection:
+
+```ruby
+class Tag < ApplicationRecord
+  connects_to database: { writing: :primary, reading: :replica }
+  has_closure_tree
+end
+
+class Category < ApplicationRecord  
+  connects_to database: { writing: :sqlite_db }
+  has_closure_tree
+end
+```
+
+Each model will use the appropriate database-specific SQL syntax and features based on its connection adapter.
+
+### Testing with Multiple Databases
+
+You can run the test suite against different databases:
+
+```bash
+# Run with PostgreSQL
+DATABASE_URL=postgres://localhost/closure_tree_test rake test
+
+# Run with MySQL  
+DATABASE_URL=mysql2://localhost/closure_tree_test rake test
+
+# Run with SQLite (default)
+rake test
+```
+
+For simultaneous multi-database testing, the test suite automatically sets up connections to all three database types when available.
+
 ## I18n
 
 You can customize error messages using [I18n](http://guides.rubyonrails.org/i18n.html):
@@ -629,33 +722,17 @@ Upgrade to MySQL 5.7.12 or later if you see [this issue](https://github.com/Clos
 
 ## Testing with Closure Tree
 
-Closure tree comes with some RSpec2/3 matchers which you may use for your tests:
+Closure tree comes with test matchers which you may use in your tests:
 
 ```ruby
-require 'spec_helper'
+require 'test_helper'
 require 'closure_tree/test/matcher'
 
-describe Category do
- # Should syntax
- it { should be_a_closure_tree }
- # Expect syntax
- it { is_expected.to be_a_closure_tree }
-end
-
-describe Label do
- # Should syntax
- it { should be_a_closure_tree.ordered }
- # Expect syntax
- it { is_expected.to be_a_closure_tree.ordered }
-end
-
-describe TodoList::Item do
- # Should syntax
- it { should be_a_closure_tree.ordered(:priority_order) }
- # Expect syntax
- it { is_expected.to be_a_closure_tree.ordered(:priority_order) }
+class CategoryTest < ActiveSupport::TestCase
+  test "should be a closure tree" do
+    assert Category.new.is_a?(ClosureTree::Model)
+  end
 end
-
 ```
 
 ## Testing
@@ -663,23 +740,19 @@ end
 Closure tree is [tested under every valid combination](https://github.com/ClosureTree/closure_tree/blob/master/.github/workflows/ci.yml) of
 
 * Ruby 3.3+
-* ActiveRecord 7.1+
+* ActiveRecord 7.2+
 * PostgreSQL, MySQL, and SQLite. Concurrency tests are only run with MySQL and PostgreSQL.
 
 ```shell
 $ bundle
-$ appraisal bundle # this will install the matrix of dependencies
-$ appraisal rake # this will run the tests in all combinations
-$ appraisal activerecord-7.0 rake # this will run the tests in AR 7.0 only
-$ appraisal activerecord-7.0 rake spec # this will run rspec in AR 7.0 only
-$ appraisal activerecord-7.0 rake test # this will run minitest in AR 7.0 only
+$ rake test # this will run the tests
 ```
 
 By default the test are run with sqlite3 only. 
 You run test with other databases by passing the database url as environment variable:
 
 ```shell
-$ DATABASE_URL=postgres://localhost/my_database appraisal activerecord-7.0 rake test 
+$ DATABASE_URL=postgres://localhost/my_database rake test 
 ```
 
 ## Change log

data/bin/rails

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+APP_PATH = File.expand_path('../test/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rake

@@ -8,11 +8,11 @@
 # this file is here to facilitate running it.
 #
 
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+                                           Pathname.new(__FILE__).realpath)
 
-bundle_binstub = File.expand_path("../bundle", __FILE__)
+bundle_binstub = File.expand_path('bundle', __dir__)
 
 if File.file?(bundle_binstub)
   if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
@@ -23,7 +23,7 @@ Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this
   end
 end
 
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
-load Gem.bin_path("rake", "rake")
+load Gem.bin_path('rake', 'rake')

data/closure_tree.gemspec

@@ -4,40 +4,34 @@ require_relative 'lib/closure_tree/version'
 
 Gem::Specification.new do |gem|
   gem.name        = 'closure_tree'
-  gem.version     = ::ClosureTree::VERSION
+  gem.version     = ClosureTree::VERSION
   gem.authors     = ['Matthew McEachen', 'Abdelkader Boudih']
   gem.email       = %w[matthew+github@mceachen.org terminale@gmail.com]
   gem.homepage    = 'https://github.com/ClosureTree/closure_tree/'
 
-  gem.summary     = %q(Easily and efficiently make your ActiveRecord model support hierarchies)
+  gem.summary     = 'Easily and efficiently make your ActiveRecord model support hierarchies'
   gem.license     = 'MIT'
 
   gem.metadata = {
-    'bug_tracker_uri'   => "https://github.com/ClosureTree/closure_tree/issues",
-    'changelog_uri'     => "https://github.com/ClosureTree/closure_tree/blob/master/CHANGELOG.md",
+    '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/#{gem.version}",
-    'homepage_uri'      => "https://closuretree.github.io/closure_tree/",
-    'source_code_uri'   => "https://github.com/ClosureTree/closure_tree",
+    'homepage_uri' => 'https://closuretree.github.io/closure_tree/',
+    'source_code_uri' => 'https://github.com/ClosureTree/closure_tree',
+    'rubygems_mfa_required' => 'true'
   }
 
-  gem.files         = `git ls-files`.split($/).reject do |f|
-    f.match(%r{^(spec|img|gemfiles)})
-  end
+  gem.files = Dir.glob('{lib}/**/*') + Dir.glob('bin/*') + %w[README.md CHANGELOG.md MIT-LICENSE closure_tree.gemspec]
 
-  gem.test_files  = gem.files.grep(%r{^spec/})
   gem.required_ruby_version = '>= 3.3.0'
 
-  gem.add_runtime_dependency 'activerecord', '>= 7.1.0'
-  gem.add_runtime_dependency 'with_advisory_lock', '>= 5.0.0', '< 6.0.0'
+  gem.add_dependency 'activerecord', '>= 7.2.0'
+  gem.add_dependency 'with_advisory_lock', '>= 7.0.0'
 
-  gem.add_development_dependency 'appraisal'
   gem.add_development_dependency 'database_cleaner'
-  gem.add_development_dependency 'generator_spec'
-  gem.add_development_dependency 'parallel'
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'minitest-reporters'
-  gem.add_development_dependency 'rspec-instafail'
-  gem.add_development_dependency 'rspec-rails'
+  gem.add_development_dependency 'parallel'
   gem.add_development_dependency 'simplecov'
   gem.add_development_dependency 'timecop'
   # gem.add_development_dependency 'byebug'

data/lib/closure_tree/active_record_support.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module ActiveRecordSupport
     delegate :quote, to: :connection
 
     def remove_prefix_and_suffix(table_name, model = ActiveRecord::Base)
-      pre, suff = model.table_name_prefix, model.table_name_suffix
+      pre = model.table_name_prefix
+      suff = model.table_name_suffix
       if table_name.start_with?(pre) && table_name.end_with?(suff)
         table_name[pre.size..-(suff.size + 1)]
       else

data/lib/closure_tree/adapter_support.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ClosureTree
+  module AdapterSupport
+    extend ActiveSupport::Concern
+
+    # This module is now only used to ensure the adapter has been loaded
+    # The actual advisory lock functionality is handled through the model's
+    # with_advisory_lock method from the with_advisory_lock gem
+  end
+end

data/lib/closure_tree/arel_helpers.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ClosureTree
+  module ArelHelpers
+    # Get model's arel table
+    def model_table
+      @model_table ||= model_class.arel_table
+    end
+
+    # Get hierarchy table from a model class
+    # This method should be called from instance methods where hierarchy_class is available
+    def hierarchy_table_for(model)
+      if model.respond_to?(:hierarchy_class)
+        model.hierarchy_class.arel_table
+      elsif model.class.respond_to?(:hierarchy_class)
+        model.class.hierarchy_class.arel_table
+      else
+        raise ArgumentError, "Cannot find hierarchy_class for #{model}"
+      end
+    end
+
+    # Get hierarchy table using the model_class
+    # This is for Support class methods
+    def hierarchy_table
+      @hierarchy_table ||= begin
+        hierarchy_class_name = options[:hierarchy_class_name] || "#{model_class}Hierarchy"
+        hierarchy_class_name.constantize.arel_table
+      end
+    end
+
+    # Helper to create an Arel node for a table with an alias
+    def aliased_table(table, alias_name)
+      table.alias(alias_name)
+    end
+
+    # Build Arel queries for hierarchy operations
+    def build_hierarchy_insert_query(hierarchy_table, node_id, parent_id)
+      x = aliased_table(hierarchy_table, 'x')
+
+      # Build the SELECT subquery - use SelectManager
+      select_query = Arel::SelectManager.new(x)
+      select_query.project(
+        x[:ancestor_id],
+        Arel.sql(quote(node_id)),
+        x[:generations] + 1
+      )
+      select_query.where(x[:descendant_id].eq(parent_id))
+
+      # Build the INSERT statement
+      insert_manager = Arel::InsertManager.new
+      insert_manager.into(hierarchy_table)
+      insert_manager.columns << hierarchy_table[:ancestor_id]
+      insert_manager.columns << hierarchy_table[:descendant_id]
+      insert_manager.columns << hierarchy_table[:generations]
+      insert_manager.select(select_query)
+
+      insert_manager
+    end
+
+    def build_hierarchy_delete_query(hierarchy_table, id)
+      # Build the innermost subquery
+      inner_subquery_manager = Arel::SelectManager.new(hierarchy_table)
+      inner_subquery_manager.project(hierarchy_table[:descendant_id])
+      inner_subquery_manager.where(
+        hierarchy_table[:ancestor_id].eq(id)
+        .or(hierarchy_table[:descendant_id].eq(id))
+      )
+      inner_subquery = inner_subquery_manager.as('x')
+
+      # Build the middle subquery with DISTINCT
+      middle_subquery = Arel::SelectManager.new
+      middle_subquery.from(inner_subquery)
+      middle_subquery.project(inner_subquery[:descendant_id]).distinct
+
+      # Build the DELETE statement
+      delete_manager = Arel::DeleteManager.new
+      delete_manager.from(hierarchy_table)
+      delete_manager.where(hierarchy_table[:descendant_id].in(middle_subquery))
+
+      delete_manager
+    end
+  end
+end

data/lib/closure_tree/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClosureTree
   class Configuration # :nodoc:
     attr_accessor :database_less

data/lib/closure_tree/deterministic_ordering.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module DeterministicOrdering
     def order_value

data/lib/closure_tree/digraphs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module Digraphs
     extend ActiveSupport::Concern
@@ -14,13 +16,13 @@ module ClosureTree
     class_methods do
       # Renders the given scope as a DOT digraph, suitable for rendering by Graphviz
       def to_dot_digraph(tree_scope)
-        id_to_instance = tree_scope.reduce({}) { |h, ea| h[ea.id] = ea; h }
+        id_to_instance = tree_scope.each_with_object({}) do |ea, h|
+          h[ea.id] = ea
+        end
         output = StringIO.new
         output << "digraph G {\n"
         tree_scope.each do |ea|
-          if id_to_instance.key? ea._ct_parent_id
-            output << "  \"#{ea._ct_parent_id}\" -> \"#{ea._ct_id}\"\n"
-          end
+          output << "  \"#{ea._ct_parent_id}\" -> \"#{ea._ct_id}\"\n" if id_to_instance.key? ea._ct_parent_id
           output << "  \"#{ea._ct_id}\" [label=\"#{ea.to_digraph_label}\"]\n"
         end
         output << "}\n"