closure_tree 7.4.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4ac0bb16bca6ba730b542b35639b067ad113e2c7010265cae6e0192425e1b82
-  data.tar.gz: 03004e7033f76268a1e96b3ee4a0c5d9066a4c716caab80c6082ddb60404b598
+  metadata.gz: 7da1033357e368c9a4d2a36b95a8e75899b61b63e872c25167dd5f8862afb454
+  data.tar.gz: '08df010ac42f946d8171152ad5ef4a8e6c1b94263cf39e5d297e4cbf805dca81'
 SHA512:
-  metadata.gz: 5eac3ad625f051cc1e5fa62165076119d1cda689b619aeb6e83c9a32bbd33f343817c867cfd97abc26d32c56346eb833d39e747ec1d60ae9abf018e79a762442
-  data.tar.gz: 6f01c8b3b6ef3382340d0743a87e34243e9283bb64d3cefec1a79a7fb23c670f8da02e0125f7497e8afa834077aa75c60830988f14b2c7e095a6f7fe3ac8e02b
+  metadata.gz: 34ef107ba1737f7e4cec6ff581149ce66b4daed0dee6b0e4bc266688a748c182e8c4e1082d38846de22671a23b2a640d80f753715f8e93fdc7889d134cd14c97
+  data.tar.gz: 300a2a3b499a8428e23f89235e409dce6cbd50378ee6406f2ab03d03b97f63d20b5365ff9adabbfaff47ce9b50a54fd5a2e80576dd5839b7d23debce98528074

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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
+- Reference ancestor_hierarchies in depth instead of ancestors to avoid n+1
+
 ## [7.4.0](https://github.com/ClosureTree/closure_tree/tree/7.4.0)
 
 [Full Changelog](https://github.com/ClosureTree/closure_tree/compare/v7.3.0...7.4.0)

data/README.md

@@ -5,8 +5,7 @@
 Common applications include modeling hierarchical data, like tags, threaded comments, page graphs in CMSes,
 and tracking user referrals.
 
-[![Join the chat at https://gitter.im/closure_tree/Lobby](https://badges.gitter.im/closure_tree/Lobby.svg)](https://gitter.im/closure_tree/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Build Status](https://api.travis-ci.org/ClosureTree/closure_tree.svg?branch=master)](http://travis-ci.org/ClosureTree/closure_tree)
+[![CI](https://github.com/ClosureTree/closure_tree/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/ClosureTree/closure_tree/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/closure_tree.svg)](https://badge.fury.io/rb/closure_tree)
 
 Dramatically more performant than
@@ -25,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 4.2, 5.0, 5.1, 5.2 and 6.0 with  Ruby 2.5 and 2.6__
+* __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)
@@ -47,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 4.2 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
 
@@ -62,11 +62,11 @@ Note that closure_tree only supports ActiveRecord 4.2 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
     ```
@@ -83,7 +83,7 @@ Note that closure_tree only supports ActiveRecord 4.2 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
@@ -385,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
@@ -412,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
 ```
@@ -426,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
 ```
@@ -526,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
 ```
@@ -534,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):
@@ -630,45 +722,38 @@ 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
 
-Closure tree is [tested under every valid combination](http://travis-ci.org/#!/ClosureTree/closure_tree) of
+Closure tree is [tested under every valid combination](https://github.com/ClosureTree/closure_tree/blob/master/.github/workflows/ci.yml) of
 
-* Ruby 2.5, 2.6 and 2.7
-* ActiveRecord 4.2, 5.x and 6.0
+* Ruby 3.3+
+* ActiveRecord 7.2+
 * PostgreSQL, MySQL, and SQLite. Concurrency tests are only run with MySQL and PostgreSQL.
 
-Assuming you're using [rbenv](https://github.com/sstephenson/rbenv), you can use ```tests.sh``` to
-run the test matrix locally.
+```shell
+$ bundle
+$ 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 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,33 +4,34 @@ require_relative 'lib/closure_tree/version'
 
 Gem::Specification.new do |gem|
   gem.name        = 'closure_tree'
-  gem.version     = ::ClosureTree::VERSION
-  gem.authors     = ['Matthew McEachen']
-  gem.email       = ['matthew-github@mceachen.org']
-  gem.homepage    = 'http://mceachen.github.io/closure_tree/'
+  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.description = gem.summary
+  gem.summary     = 'Easily and efficiently make your ActiveRecord model support hierarchies'
   gem.license     = 'MIT'
 
-  gem.files         = `git ls-files`.split($/).reject do |f|
-    f.match(%r{^(spec|img|gemfiles)})
-  end
+  gem.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/#{gem.version}",
+    'homepage_uri' => 'https://closuretree.github.io/closure_tree/',
+    'source_code_uri' => 'https://github.com/ClosureTree/closure_tree',
+    'rubygems_mfa_required' => 'true'
+  }
 
-  gem.test_files  = gem.files.grep(%r{^spec/})
-  gem.required_ruby_version = '>= 2.0.0'
+  gem.files = Dir.glob('{lib}/**/*') + Dir.glob('bin/*') + %w[README.md CHANGELOG.md MIT-LICENSE closure_tree.gemspec]
 
-  gem.add_runtime_dependency 'activerecord', '>= 4.2.10'
-  gem.add_runtime_dependency 'with_advisory_lock', '>= 4.0.0'
+  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_development_dependency 'appraisal'
   gem.add_development_dependency 'database_cleaner'
-  gem.add_development_dependency 'generator_spec'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'minitest-reporters'
   gem.add_development_dependency 'parallel'
-  gem.add_development_dependency 'pg'
-  gem.add_development_dependency 'rspec-instafail'
-  gem.add_development_dependency 'rspec-rails'
-  gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'simplecov'
   gem.add_development_dependency 'timecop'
   # gem.add_development_dependency 'byebug'

data/lib/closure_tree/active_record_support.rb

@@ -1,20 +1,12 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module ActiveRecordSupport
+    delegate :quote, to: :connection
 
-    def quote(field)
-      connection.quote(field)
-    end
-
-    def ensure_fixed_table_name(table_name)
-      [
-        ActiveRecord::Base.table_name_prefix,
-        remove_prefix_and_suffix(table_name),
-        ActiveRecord::Base.table_name_suffix
-      ].compact.join
-    end
-
-    def remove_prefix_and_suffix(table_name)
-      pre, suff = ActiveRecord::Base.table_name_prefix, ActiveRecord::Base.table_name_suffix
+    def remove_prefix_and_suffix(table_name, model = ActiveRecord::Base)
+      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
@@ -11,16 +13,16 @@ module ClosureTree
       _ct.has_name? ? read_attribute(_ct.name_column) : to_s
     end
 
-    module ClassMethods
+    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"