closure_tree 8.0.0 → 9.0.0

data/lib/closure_tree/finders.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module Finders
     extend ActiveSupport::Concern
@@ -5,6 +7,7 @@ module ClosureTree
     # Find a descendant node whose +ancestry_path+ will be ```self.ancestry_path + path```
     def find_by_path(path, attributes = {})
       return self if path.empty?
+
       self.class.find_by_path(path, attributes, id)
     end
 
@@ -20,13 +23,13 @@ module ClosureTree
       _ct.with_advisory_lock do
         # shenanigans because children.create is bound to the superclass
         # (in the case of polymorphism):
-        child = self.children.where(attrs).first || begin
+        child = children.where(attrs).first || begin
           # Support STI creation by using base_class:
           _ct.create(self.class, attrs).tap do |ea|
             # We know that there isn't a cycle, because we just created it, and
             # cycle detection is expensive when the node is deep.
             ea._ct_skip_cycle_detection!
-            self.children << ea
+            children << ea
           end
         end
         child.find_or_create_by_path(subpath, attributes)
@@ -34,15 +37,24 @@ module ClosureTree
     end
 
     def find_all_by_generation(generation_level)
-      s = _ct.base_class.joins(<<-SQL.squish)
-        INNER JOIN (
-          SELECT descendant_id
-          FROM #{_ct.quoted_hierarchy_table_name}
-          WHERE ancestor_id = #{_ct.quote(self.id)}
-          GROUP BY descendant_id
-          HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
-        ) #{ _ct.t_alias_keyword } descendants ON (#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} = descendants.descendant_id)
-      SQL
+      hierarchy_table = self.class.hierarchy_class.arel_table
+      model_table = self.class.arel_table
+
+      # Build the subquery
+      descendants_subquery = hierarchy_table
+                             .project(hierarchy_table[:descendant_id])
+                             .where(hierarchy_table[:ancestor_id].eq(id))
+                             .group(hierarchy_table[:descendant_id])
+                             .having(hierarchy_table[:generations].maximum.eq(generation_level.to_i))
+                             .as('descendants')
+
+      # Build the join
+      join_source = model_table
+                    .join(descendants_subquery)
+                    .on(model_table[_ct.base_class.primary_key].eq(descendants_subquery[:descendant_id]))
+                    .join_sources
+
+      s = _ct.base_class.joins(join_source)
       _ct.scope_with_order(s)
     end
 
@@ -51,7 +63,6 @@ module ClosureTree
     end
 
     class_methods do
-
       def without_instance(instance)
         if instance.new_record?
           all
@@ -70,87 +81,125 @@ module ClosureTree
       end
 
       def leaves
-        s = joins(<<-SQL.squish)
-          INNER JOIN (
-            SELECT ancestor_id
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY ancestor_id
-            HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = 0
-          ) #{ _ct.t_alias_keyword } leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
-        SQL
+        hierarchy_table = hierarchy_class.arel_table
+        model_table = arel_table
+
+        # Build the subquery for leaves (nodes with no children)
+        leaves_subquery = hierarchy_table
+                          .project(hierarchy_table[:ancestor_id])
+                          .group(hierarchy_table[:ancestor_id])
+                          .having(hierarchy_table[:generations].maximum.eq(0))
+                          .as('leaves')
+
+        # Build the join
+        join_source = model_table
+                      .join(leaves_subquery)
+                      .on(model_table[primary_key].eq(leaves_subquery[:ancestor_id]))
+                      .join_sources
+
+        s = joins(join_source)
         _ct.scope_with_order(s.readonly(false))
       end
 
       def with_ancestor(*ancestors)
         ancestor_ids = ancestors.map { |ea| ea.is_a?(ActiveRecord::Base) ? ea._ct_id : ea }
-        scope = ancestor_ids.blank? ? all : joins(:ancestor_hierarchies).
-          where("#{_ct.hierarchy_table_name}.ancestor_id" => ancestor_ids).
-          where("#{_ct.hierarchy_table_name}.generations > 0").
-          readonly(false)
+        scope = if ancestor_ids.blank?
+                  all
+                else
+                  joins(:ancestor_hierarchies)
+                    .where("#{_ct.hierarchy_table_name}.ancestor_id" => ancestor_ids)
+                    .where("#{_ct.hierarchy_table_name}.generations > 0")
+                    .readonly(false)
+                end
         _ct.scope_with_order(scope)
       end
 
       def with_descendant(*descendants)
         descendant_ids = descendants.map { |ea| ea.is_a?(ActiveRecord::Base) ? ea._ct_id : ea }
-        scope = descendant_ids.blank? ? all : joins(:descendant_hierarchies).
-          where("#{_ct.hierarchy_table_name}.descendant_id" => descendant_ids).
-          where("#{_ct.hierarchy_table_name}.generations > 0").
-          readonly(false)
+        scope = if descendant_ids.blank?
+                  all
+                else
+                  joins(:descendant_hierarchies)
+                    .where("#{_ct.hierarchy_table_name}.descendant_id" => descendant_ids)
+                    .where("#{_ct.hierarchy_table_name}.generations > 0")
+                    .readonly(false)
+                end
         _ct.scope_with_order(scope)
       end
 
       def lowest_common_ancestor(*descendants)
         descendants = descendants.first if descendants.length == 1 && descendants.first.respond_to?(:each)
         ancestor_id = hierarchy_class
-          .where(descendant_id: descendants)
-          .group(:ancestor_id)
-          .having("COUNT(ancestor_id) = #{descendants.count}")
-          .order(Arel.sql('MIN(generations) ASC'))
-          .limit(1)
-          .pluck(:ancestor_id).first
+                      .where(descendant_id: descendants)
+                      .group(:ancestor_id)
+                      .having("COUNT(ancestor_id) = #{descendants.count}")
+                      .order(Arel.sql('MIN(generations) ASC'))
+                      .limit(1)
+                      .pluck(:ancestor_id).first
 
         find_by(primary_key => ancestor_id) if ancestor_id
       end
 
       def find_all_by_generation(generation_level)
-        s = joins(<<-SQL.squish)
-          INNER JOIN (
-            SELECT #{primary_key} as root_id
-            FROM #{_ct.quoted_table_name}
-            WHERE #{_ct.quoted_parent_column_name} IS NULL
-          ) #{ _ct.t_alias_keyword }  roots ON (1 = 1)
-          INNER JOIN (
-            SELECT ancestor_id, descendant_id
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY ancestor_id, descendant_id
-            HAVING MAX(generations) = #{generation_level.to_i}
-          ) #{ _ct.t_alias_keyword }  descendants ON (
-            #{_ct.quoted_table_name}.#{primary_key} = descendants.descendant_id
-            AND roots.root_id = descendants.ancestor_id
-          )
-        SQL
+        hierarchy_table = hierarchy_class.arel_table
+        model_table = arel_table
+
+        # Build the roots subquery
+        roots_subquery = model_table
+                         .project(model_table[primary_key].as('root_id'))
+                         .where(model_table[_ct.parent_column_sym].eq(nil))
+                         .as('roots')
+
+        # Build the descendants subquery
+        descendants_subquery = hierarchy_table
+                               .project(
+                                 hierarchy_table[:ancestor_id],
+                                 hierarchy_table[:descendant_id]
+                               )
+                               .group(hierarchy_table[:ancestor_id], hierarchy_table[:descendant_id])
+                               .having(hierarchy_table[:generations].maximum.eq(generation_level.to_i))
+                               .as('descendants')
+
+        # Build the joins
+        # Note: We intentionally use a cartesian product join (CROSS JOIN) here.
+        # This allows us to find all nodes at a specific generation level across all root nodes.
+        # The 1=1 condition creates this cartesian product in a database-agnostic way.
+        join_roots = model_table
+                     .join(roots_subquery)
+                     .on(Arel.sql('1 = 1'))
+
+        join_descendants = join_roots
+                           .join(descendants_subquery)
+                           .on(
+                             model_table[primary_key].eq(descendants_subquery[:descendant_id])
+                             .and(roots_subquery[:root_id].eq(descendants_subquery[:ancestor_id]))
+                           )
+
+        s = joins(join_descendants.join_sources)
         _ct.scope_with_order(s)
       end
 
       # Find the node whose +ancestry_path+ is +path+
       def find_by_path(path, attributes = {}, parent_id = nil)
         return nil if path.blank?
+
         path = _ct.build_ancestry_attr_path(path, attributes)
-        if path.size > _ct.max_join_tables
-          return _ct.find_by_large_path(path, attributes, parent_id)
-        end
+        return _ct.find_by_large_path(path, attributes, parent_id) if path.size > _ct.max_join_tables
+
         scope = where(path.pop)
         last_joined_table = _ct.table_name
+
         path.reverse.each_with_index do |ea, idx|
           next_joined_table = "p#{idx}"
           scope = scope.joins(<<-SQL.squish)
-            INNER JOIN #{_ct.quoted_table_name} #{ _ct.t_alias_keyword } #{next_joined_table}
+            INNER JOIN #{_ct.quoted_table_name} #{_ct.t_alias_keyword} #{next_joined_table}
               ON #{next_joined_table}.#{_ct.quoted_id_column_name} =
  #{connection.quote_table_name(last_joined_table)}.#{_ct.quoted_parent_column_name}
           SQL
           scope = _ct.scoped_attributes(scope, ea, next_joined_table)
           last_joined_table = next_joined_table
         end
+
         scope.where("#{last_joined_table}.#{_ct.parent_column_name}" => parent_id).readonly(false).first
       end
 

data/lib/closure_tree/has_closure_tree.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module HasClosureTree
     def has_closure_tree(options = {})
@@ -11,7 +13,8 @@ module ClosureTree
         :dont_order_roots,
         :numeric_order,
         :touch,
-        :with_advisory_lock
+        :with_advisory_lock,
+        :advisory_lock_name
       )
 
       class_attribute :_ct
@@ -37,6 +40,6 @@ module ClosureTree
       raise e unless ClosureTree.configuration.database_less
     end
 
-    alias_method :acts_as_tree, :has_closure_tree
+    alias acts_as_tree has_closure_tree
   end
 end

data/lib/closure_tree/has_closure_tree_root.rb

@@ -1,38 +1,33 @@
+# frozen_string_literal: true
+
 module ClosureTree
   class MultipleRootError < StandardError; end
   class RootOrderingDisabledError < StandardError; end
 
   module HasClosureTreeRoot
-
     def has_closure_tree_root(assoc_name, options = {})
-       options[:class_name] ||= assoc_name.to_s.sub(/\Aroot_/, "").classify
-      options[:foreign_key] ||= self.name.underscore << "_id"
+      options[:class_name] ||= assoc_name.to_s.sub(/\Aroot_/, '').classify
+      options[:foreign_key] ||= name.underscore << '_id'
 
       has_one assoc_name, -> { where(parent: nil) }, **options
 
       # Fetches the association, eager loading all children and given associations
       define_method("#{assoc_name}_including_tree") do |*args|
         reload = false
-        reload = args.shift if args && (args.first == true || args.first == false)
+        reload = args.shift if args && [true, false].include?(args.first)
         assoc_map = args
         assoc_map = [nil] if assoc_map.blank?
 
         # Memoize
         @closure_tree_roots ||= {}
         @closure_tree_roots[assoc_name] ||= {}
-        unless reload
-          if @closure_tree_roots[assoc_name].has_key?(assoc_map)
-            return @closure_tree_roots[assoc_name][assoc_map]
-          end
-        end
+        return @closure_tree_roots[assoc_name][assoc_map] if !reload && @closure_tree_roots[assoc_name].key?(assoc_map)
 
         roots = options[:class_name].constantize.where(parent: nil, options[:foreign_key] => id).to_a
 
         return nil if roots.empty?
 
-        if roots.size > 1
-          raise MultipleRootError.new("#{self.class.name}: has_closure_tree_root requires a single root")
-        end
+        raise MultipleRootError, "#{self.class.name}: has_closure_tree_root requires a single root" if roots.size > 1
 
         temp_root = roots.first
         root = nil
@@ -68,11 +63,11 @@ module ClosureTree
           end
 
           # Pre-assign inverse association back to this class, if it exists on target class.
-          if inverse
-            inverse_assoc = node.association(inverse.name)
-            inverse_assoc.loaded!
-            inverse_assoc.target = self
-          end
+          next unless inverse
+
+          inverse_assoc = node.association(inverse.name)
+          inverse_assoc.loaded!
+          inverse_assoc.target = self
         end
 
         @closure_tree_roots[assoc_name][assoc_map] = root

data/lib/closure_tree/hash_tree.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module HashTree
     extend ActiveSupport::Concern
@@ -7,7 +9,6 @@ module ClosureTree
     end
 
     class_methods do
-
       # There is no default depth limit. This might be crazy-big, depending
       # on your tree shape. Hash huge trees at your own peril!
       def hash_tree(options = {})

data/lib/closure_tree/hash_tree_support.rb

@@ -1,19 +1,44 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module HashTreeSupport
     def default_tree_scope(scope, limit_depth = nil)
-        # Deepest generation, within limit, for each descendant
-        # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
-        having_clause = limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ''
-        generation_depth = <<-SQL.squish
-          INNER JOIN (
-            SELECT descendant_id, MAX(generations) as depth
-            FROM #{quoted_hierarchy_table_name}
-            GROUP BY descendant_id
-            #{having_clause}
-          ) #{ t_alias_keyword } generation_depth
-            ON #{quoted_table_name}.#{model_class.primary_key} = generation_depth.descendant_id
-        SQL
-        scope_with_order(scope.joins(generation_depth), 'generation_depth.depth')
+      # Deepest generation, within limit, for each descendant
+      # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
+
+      # Get the hierarchy table for the scope's model class
+      hierarchy_table_arel = if scope.respond_to?(:hierarchy_class)
+                               scope.hierarchy_class.arel_table
+                             elsif scope.klass.respond_to?(:hierarchy_class)
+                               scope.klass.hierarchy_class.arel_table
+                             else
+                               hierarchy_table
+                             end
+
+      model_table_arel = scope.klass.arel_table
+
+      # Build the subquery using Arel
+      subquery = hierarchy_table_arel
+                 .project(
+                   hierarchy_table_arel[:descendant_id],
+                   hierarchy_table_arel[:generations].maximum.as('depth')
+                 )
+                 .group(hierarchy_table_arel[:descendant_id])
+
+      # Add HAVING clause if limit_depth is specified
+      subquery = subquery.having(hierarchy_table_arel[:generations].maximum.lteq(limit_depth - 1)) if limit_depth
+
+      generation_depth_alias = subquery.as('generation_depth')
+
+      # Build the join
+      join_condition = model_table_arel[scope.klass.primary_key].eq(generation_depth_alias[:descendant_id])
+
+      join_source = model_table_arel
+                    .join(generation_depth_alias)
+                    .on(join_condition)
+                    .join_sources
+
+      scope_with_order(scope.joins(join_source), 'generation_depth.depth')
     end
 
     def hash_tree(tree_scope, limit_depth = nil)

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module ClosureTree
@@ -21,11 +23,12 @@ module ClosureTree
 
     def _ct_validate
       if !(defined? @_ct_skip_cycle_detection) &&
-        !new_record? && # don't validate for cycles if we're a new record
-        changes[_ct.parent_column_name] && # don't validate for cycles if we didn't change our parent
-        parent.present? && # don't validate if we're root
-        parent.self_and_ancestors.include?(self) # < this is expensive :\
-        errors.add(_ct.parent_column_sym, I18n.t('closure_tree.loop_error', default: 'You cannot add an ancestor as a descendant'))
+         !new_record? && # don't validate for cycles if we're a new record
+         changes[_ct.parent_column_name] && # don't validate for cycles if we didn't change our parent
+         parent.present? && # don't validate if we're root
+         parent.self_and_ancestors.include?(self) # < this is expensive :\
+        errors.add(_ct.parent_column_sym,
+                   I18n.t('closure_tree.loop_error', default: 'You cannot add an ancestor as a descendant'))
       end
     end
 
@@ -35,10 +38,8 @@ module ClosureTree
     end
 
     def _ct_after_save
-      if public_send(:saved_changes)[_ct.parent_column_name] || @was_new_record
-        rebuild!
-      end
-      if public_send(:saved_changes)[_ct.parent_column_name] && !@was_new_record
+      rebuild! if saved_changes[_ct.parent_column_name] || @was_new_record
+      if saved_changes[_ct.parent_column_name] && !@was_new_record
         # Resetting the ancestral collections addresses
         # https://github.com/mceachen/closure_tree/issues/68
         ancestor_hierarchies.reload
@@ -52,9 +53,7 @@ module ClosureTree
     def _ct_before_destroy
       _ct.with_advisory_lock do
         delete_hierarchy_references
-        if _ct.options[:dependent] == :nullify
-          self.class.find(self.id).children.find_each { |c| c.rebuild! }
-        end
+        self.class.find(id).children.find_each(&:rebuild!) if _ct.options[:dependent] == :nullify
       end
       true # don't prevent destruction
     end
@@ -62,7 +61,7 @@ module ClosureTree
     def rebuild!(called_by_rebuild = false)
       _ct.with_advisory_lock do
         delete_hierarchy_references unless (defined? @was_new_record) && @was_new_record
-        hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
+        hierarchy_class.create!(ancestor: self, descendant: self, generations: 0)
         unless root?
           _ct.connection.execute <<-SQL.squish
             INSERT INTO #{_ct.quoted_hierarchy_table_name}
@@ -76,7 +75,7 @@ module ClosureTree
         if _ct.order_is_numeric? && !@_ct_skip_sort_order_maintenance
           _ct_reorder_prior_siblings_if_parent_changed
           # Prevent double-reordering of siblings:
-          _ct_reorder_siblings if !called_by_rebuild
+          _ct_reorder_siblings unless called_by_rebuild
         end
 
         children.find_each { |c| c.rebuild!(true) }
@@ -91,16 +90,10 @@ module ClosureTree
         # It shouldn't affect performance of postgresql.
         # See http://dev.mysql.com/doc/refman/5.0/en/subquery-errors.html
         # Also: PostgreSQL doesn't support INNER JOIN on DELETE, so we can't use that.
-        _ct.connection.execute <<-SQL.squish
-          DELETE FROM #{_ct.quoted_hierarchy_table_name}
-          WHERE descendant_id IN (
-            SELECT DISTINCT descendant_id
-            FROM (SELECT descendant_id
-              FROM #{_ct.quoted_hierarchy_table_name}
-              WHERE ancestor_id = #{_ct.quote(id)}
-                 OR descendant_id = #{_ct.quote(id)}
-            ) #{ _ct.t_alias_keyword } x )
-        SQL
+
+        hierarchy_table = hierarchy_class.arel_table
+        delete_query = _ct.build_hierarchy_delete_query(hierarchy_table, id)
+        _ct.connection.execute(delete_query.to_sql)
       end
     end
 
@@ -118,8 +111,8 @@ module ClosureTree
       def cleanup!
         hierarchy_table = hierarchy_class.arel_table
 
-        [:descendant_id, :ancestor_id].each do |foreign_key|
-          alias_name = foreign_key.to_s.split('_').first + "s"
+        %i[descendant_id ancestor_id].each do |foreign_key|
+          alias_name = "#{foreign_key.to_s.split('_').first}s"
           alias_table = Arel::Table.new(table_name).alias(alias_name)
           arel_join = hierarchy_table.join(alias_table, Arel::Nodes::OuterJoin)
                                      .on(alias_table[primary_key].eq(hierarchy_table[foreign_key]))

data/lib/closure_tree/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module ClosureTree
@@ -5,44 +7,42 @@ module ClosureTree
     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
+                 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
+      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'
+               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
+               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'
+               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
+               through: :descendant_hierarchies,
+               source: :descendant
     end
 
     # Delegate to the Support instance on the class:
@@ -80,7 +80,7 @@ module ClosureTree
       ancestor_hierarchies.size - 1
     end
 
-    alias_method :level, :depth
+    alias level depth
 
     # enumerable of ancestors, immediate parent is first, root is last.
     def ancestors
@@ -147,17 +147,17 @@ module ClosureTree
 
     # node is record's ancestor
     def descendant_of?(node)
-      self.ancestors.include? node
+      ancestors.include? node
     end
 
     # node is record's parent
     def child_of?(node)
-      self.parent == node
+      parent == node
     end
 
     # node and record have a same root
     def family_of?(node)
-      self.root == node.root
+      root == node.root
     end
 
     # Alias for appending to the children collection.