closure_tree 7.3.0 → 9.1.0

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 # This module is only included if the order column is an integer.
@@ -10,15 +12,10 @@ module ClosureTree
     end
 
     def _ct_reorder_prior_siblings_if_parent_changed
-      as_5_1 = ActiveSupport.version >= Gem::Version.new('5.1.0')
-      change_method = as_5_1 ? :saved_change_to_attribute? : :attribute_changed?
-
-      if public_send(change_method, _ct.parent_column_name) && !@was_new_record
-        attribute_method = as_5_1 ? :attribute_before_last_save : :attribute_was
+      return unless saved_change_to_attribute?(_ct.parent_column_name) && !@was_new_record
 
-        was_parent_id = public_send(attribute_method, _ct.parent_column_name)
-        _ct.reorder_with_parent_id(was_parent_id)
-      end
+      was_parent_id = attribute_before_last_save(_ct.parent_column_name)
+      _ct.reorder_with_parent_id(was_parent_id)
     end
 
     def _ct_reorder_siblings(minimum_sort_order_value = nil)
@@ -32,60 +29,94 @@ module ClosureTree
 
     def self_and_descendants_preordered
       # TODO: raise NotImplementedError if sort_order is not numeric and not null?
-      join_sql = <<-SQL
-        JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
-          ON anc_hier.descendant_id = #{_ct.quoted_hierarchy_table_name}.descendant_id
-        JOIN #{_ct.quoted_table_name} anc
-          ON anc.#{_ct.quoted_id_column_name} = anc_hier.ancestor_id
-        JOIN #{_ct.quoted_hierarchy_table_name} depths
-          ON depths.ancestor_id = #{_ct.quote(self.id)} AND depths.descendant_id = anc.#{_ct.quoted_id_column_name}
-      SQL
+      hierarchy_table = self.class.hierarchy_class.arel_table
+      model_table = self.class.arel_table
+
+      # Create aliased tables for the joins
+      anc_hier = _ct.aliased_table(hierarchy_table, 'anc_hier')
+      anc = _ct.aliased_table(model_table, 'anc')
+      depths = _ct.aliased_table(hierarchy_table, 'depths')
+
+      # Build the join conditions using Arel
+      join_anc_hier = hierarchy_table
+                      .join(anc_hier)
+                      .on(anc_hier[:descendant_id].eq(hierarchy_table[:descendant_id]))
+
+      join_anc = join_anc_hier
+                 .join(anc)
+                 .on(anc[self.class.primary_key].eq(anc_hier[:ancestor_id]))
+
+      join_depths = join_anc
+                    .join(depths)
+                    .on(
+                      depths[:ancestor_id].eq(id)
+                      .and(depths[:descendant_id].eq(anc[self.class.primary_key]))
+                    )
 
       self_and_descendants
-        .joins(join_sql)
+        .joins(join_depths.join_sources)
         .group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}")
         .reorder(self.class._ct_sum_order_by(self))
     end
 
-    module ClassMethods
-
+    class_methods do
       # If node is nil, order the whole tree.
       def _ct_sum_order_by(node = nil)
-        stats_sql = <<-SQL.squish
-          SELECT
-            count(*) as total_descendants,
-            max(generations) as max_depth
-          FROM #{_ct.quoted_hierarchy_table_name}
-        SQL
-        stats_sql += " WHERE ancestor_id = #{_ct.quote(node.id)}" if node
-        h = _ct.connection.select_one(stats_sql)
+        # Build the stats query using Arel
+        hierarchy_table = hierarchy_class.arel_table
+
+        query = hierarchy_table
+                .project(
+                  Arel.star.count.as('total_descendants'),
+                  hierarchy_table[:generations].maximum.as('max_depth')
+                )
+
+        query = query.where(hierarchy_table[:ancestor_id].eq(node.id)) if node
+
+        h = _ct.connection.select_one(query.to_sql)
 
         depth_column = node ? 'depths.generations' : 'depths.max_depth'
 
-        node_score = "(1 + anc.#{_ct.quoted_order_column(false)}) * " +
-          "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - #{depth_column})"
+        node_score = "(1 + anc.#{_ct.quoted_order_column(false)}) * " \
+                     "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - #{depth_column})"
 
         # We want the NULLs to be first in case we are not ordering roots and they have NULL order.
         Arel.sql("SUM(#{node_score}) IS NULL DESC, SUM(#{node_score})")
       end
 
       def roots_and_descendants_preordered
-        if _ct.dont_order_roots
-          raise ClosureTree::RootOrderingDisabledError.new("Root ordering is disabled on this model")
-        end
-
-        join_sql = <<-SQL.squish
-          JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
-            ON anc_hier.descendant_id = #{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}
-          JOIN #{_ct.quoted_table_name} anc
-            ON anc.#{_ct.quoted_id_column_name} = anc_hier.ancestor_id
-          JOIN (
-            SELECT descendant_id, max(generations) AS max_depth
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY descendant_id
-          ) #{ _ct.t_alias_keyword } depths ON depths.descendant_id = anc.#{_ct.quoted_id_column_name}
-        SQL
-        joins(join_sql)
+        raise ClosureTree::RootOrderingDisabledError, 'Root ordering is disabled on this model' if _ct.dont_order_roots
+
+        hierarchy_table = hierarchy_class.arel_table
+        model_table = arel_table
+
+        # Create aliased tables
+        anc_hier = _ct.aliased_table(hierarchy_table, 'anc_hier')
+        anc = _ct.aliased_table(model_table, 'anc')
+
+        # Build the subquery for depths
+        depths_subquery = hierarchy_table
+                          .project(
+                            hierarchy_table[:descendant_id],
+                            hierarchy_table[:generations].maximum.as('max_depth')
+                          )
+                          .group(hierarchy_table[:descendant_id])
+                          .as('depths')
+
+        # Build the join conditions
+        join_anc_hier = model_table
+                        .join(anc_hier)
+                        .on(anc_hier[:descendant_id].eq(model_table[primary_key]))
+
+        join_anc = join_anc_hier
+                   .join(anc)
+                   .on(anc[primary_key].eq(anc_hier[:ancestor_id]))
+
+        join_depths = join_anc
+                      .join(depths_subquery)
+                      .on(depths_subquery[:descendant_id].eq(anc[primary_key]))
+
+        joins(join_depths.join_sources)
           .group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}")
           .reorder(_ct_sum_order_by)
       end
@@ -116,10 +147,10 @@ module ClosureTree
     end
 
     def add_sibling(sibling, add_after = true)
-      fail "can't add self as sibling" if self == sibling
+      raise "can't add self as sibling" if self == sibling
 
       if _ct.dont_order_roots && parent.nil?
-        raise ClosureTree::RootOrderingDisabledError.new("Root ordering is disabled on this model")
+        raise ClosureTree::RootOrderingDisabledError, 'Root ordering is disabled on this model'
       end
 
       # Make sure self isn't dirty, because we're going to call reload:
@@ -127,31 +158,30 @@ module ClosureTree
 
       _ct.with_advisory_lock do
         prior_sibling_parent = sibling.parent
-        reorder_from_value = if prior_sibling_parent == self.parent
-          [self.order_value, sibling.order_value].compact.min
-        else
-          self.order_value
-        end
-
-        sibling.order_value = self.order_value
-        sibling.parent = self.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 = self.reload.order_value < sibling.reload.order_value
+        sibling_is_after = reload.order_value < sibling.reload.order_value
         if add_after != sibling_is_after
           # We need to flip the sort orders:
-          self_ov, sib_ov = self.order_value, sibling.order_value
+          self_ov = order_value
+          sib_ov = sibling.order_value
           update_order_value(sib_ov)
           sibling.update_order_value(self_ov)
         end
 
-        if prior_sibling_parent != self.parent
-          prior_sibling_parent.try(:_ct_reorder_children)
-        end
+        prior_sibling_parent.try(:_ct_reorder_children) if prior_sibling_parent != parent
         sibling
       end
     end

data/lib/closure_tree/numeric_order_support.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module NumericOrderSupport
-
     def self.adapter_for_connection(connection)
-      das = WithAdvisoryLock::DatabaseAdapterSupport.new(connection)
-      if das.postgresql?
+      adapter_name = connection.adapter_name.downcase
+      if adapter_name.include?('postgresql') || adapter_name.include?('postgis')
         ::ClosureTree::NumericOrderSupport::PostgreSQLAdapter
-      elsif das.mysql?
+      elsif adapter_name.include?('mysql') || adapter_name.include?('trilogy')
         ::ClosureTree::NumericOrderSupport::MysqlAdapter
       else
         ::ClosureTree::NumericOrderSupport::GenericAdapter
@@ -15,11 +16,12 @@ module ClosureTree
     module MysqlAdapter
       def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
         return if parent_id.nil? && dont_order_roots
+
         min_where = if minimum_sort_order_value
-          "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
-        else
-          ""
-        end
+                      "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
+                    else
+                      ''
+                    end
         connection.execute 'SET @i = 0'
         connection.execute <<-SQL.squish
           UPDATE #{quoted_table_name}
@@ -33,11 +35,12 @@ module ClosureTree
     module PostgreSQLAdapter
       def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
         return if parent_id.nil? && dont_order_roots
+
         min_where = if minimum_sort_order_value
-          "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
-        else
-          ""
-        end
+                      "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
+                    else
+                      ''
+                    end
         connection.execute <<-SQL.squish
           UPDATE #{quoted_table_name}
           SET #{quoted_order_column(false)} = t.seq + #{minimum_sort_order_value.to_i - 1}
@@ -59,12 +62,11 @@ module ClosureTree
     module GenericAdapter
       def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil)
         return if parent_id.nil? && dont_order_roots
-        scope = model_class.
-          where(parent_column_sym => parent_id).
-          order(nulls_last_order_by)
-        if minimum_sort_order_value
-          scope = scope.where("#{quoted_order_column} >= #{minimum_sort_order_value}")
-        end
+
+        scope = model_class
+                .where(parent_column_sym => parent_id)
+                .order(nulls_last_order_by)
+        scope = scope.where("#{quoted_order_column} >= #{minimum_sort_order_value}") if minimum_sort_order_value
         scope.each_with_index do |ea, idx|
           ea.update_order_value(idx + minimum_sort_order_value.to_i)
         end

data/lib/closure_tree/support.rb

@@ -1,9 +1,4 @@
-require 'closure_tree/support_flags'
-require 'closure_tree/support_attributes'
-require 'closure_tree/numeric_order_support'
-require 'closure_tree/active_record_support'
-require 'closure_tree/hash_tree_support'
-require 'with_advisory_lock'
+# frozen_string_literal: true
 
 # This class and mixins are an effort to reduce the namespace pollution to models that act_as_tree.
 module ClosureTree
@@ -12,42 +7,40 @@ module ClosureTree
     include ClosureTree::SupportAttributes
     include ClosureTree::ActiveRecordSupport
     include ClosureTree::HashTreeSupport
+    include ClosureTree::ArelHelpers
 
-    attr_reader :model_class
-    attr_reader :options
+    attr_reader :model_class, :options
 
     def initialize(model_class, options)
       @model_class = model_class
+
       @options = {
-        :parent_column_name => 'parent_id',
-        :dependent => :nullify, # or :destroy or :delete_all -- see the README
-        :name_column => 'name',
-        :with_advisory_lock => true,
-        :numeric_order => false
+        parent_column_name: 'parent_id',
+        dependent: :nullify, # or :destroy or :delete_all -- see the README
+        name_column: 'name',
+        with_advisory_lock: true, # This will be overridden by adapter support
+        numeric_order: false
       }.merge(options)
       raise ArgumentError, "name_column can't be 'path'" if options[:name_column] == 'path'
-      if order_is_numeric?
-        extend NumericOrderSupport.adapter_for_connection(connection)
-      end
+
+      return unless order_is_numeric?
+
+      extend NumericOrderSupport.adapter_for_connection(connection)
     end
 
     def hierarchy_class_for_model
-      parent_class = ActiveSupport::VERSION::MAJOR >= 6 ? model_class.module_parent : model_class.parent
-      hierarchy_class = parent_class.const_set(short_hierarchy_class_name, Class.new(ActiveRecord::Base))
-      use_attr_accessible = use_attr_accessible?
-      include_forbidden_attributes_protection = include_forbidden_attributes_protection?
+      parent_class = model_class.module_parent
+      hierarchy_class = parent_class.const_set(short_hierarchy_class_name, Class.new(model_class.superclass))
       model_class_name = model_class.to_s
       hierarchy_class.class_eval do
-        include ActiveModel::ForbiddenAttributesProtection if include_forbidden_attributes_protection
         belongs_to :ancestor, class_name: model_class_name
         belongs_to :descendant, class_name: model_class_name
-        attr_accessible :ancestor, :descendant, :generations if use_attr_accessible
         def ==(other)
           self.class == other.class && ancestor_id == other.ancestor_id && descendant_id == other.descendant_id
         end
         alias :eql? :==
         def hash
-          ancestor_id.hash << 31 ^ descendant_id.hash
+          (ancestor_id.hash << 31) ^ descendant_id.hash
         end
       end
       hierarchy_class.table_name = hierarchy_table_name
@@ -59,36 +52,30 @@ module ClosureTree
       # because they may have overridden the table name, which is what we want to be consistent with
       # in order for the schema to make sense.
       tablename = options[:hierarchy_table_name] ||
-        remove_prefix_and_suffix(table_name).singularize + "_hierarchies"
+                  "#{remove_prefix_and_suffix(table_name, model_class).singularize}_hierarchies"
 
-      ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
+      [model_class.table_name_prefix, tablename, model_class.table_name_suffix].join
     end
 
     def with_order_option(opts)
-      if order_option?
-        opts[:order] = [opts[:order], order_by].compact.join(",")
-      end
+      opts[:order] = [opts[:order], order_by].compact.join(',') if order_option?
       opts
     end
 
     def scope_with_order(scope, additional_order_by = nil)
       if order_option?
-        scope.order(*([additional_order_by, order_by].compact))
+        scope.order(*[additional_order_by, order_by].compact)
       else
         additional_order_by ? scope.order(additional_order_by) : scope
       end
     end
 
-    def belongs_to_with_optional_option(opts)
-      ActiveRecord::VERSION::MAJOR < 5 ? opts.except(:optional) : opts
-    end
-
     # lambda-ize the order, but don't apply the default order_option
     def has_many_order_without_option(order_by_opt)
-      [lambda { order(order_by_opt.call) }]
+      [-> { order(order_by_opt.call) }]
     end
 
-    def has_many_order_with_option(order_by_opt=nil)
+    def has_many_order_with_option(order_by_opt = nil)
       order_options = [order_by_opt, order_by].compact
       [lambda {
         order_options = order_options.map { |o| o.is_a?(Proc) ? o.call : o }
@@ -109,9 +96,9 @@ module ClosureTree
     end
 
     def with_advisory_lock(&block)
-      if options[:with_advisory_lock]
+      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
-          transaction { yield }
+          transaction(&block)
         end
       else
         yield
@@ -123,7 +110,7 @@ module ClosureTree
       unless path.first.is_a?(Hash)
         if subclass? && has_inheritance_column?
           attributes = attributes.with_indifferent_access
-          attributes[inheritance_column] ||= self.sti_name
+          attributes[inheritance_column] ||= sti_name
         end
         path = path.map { |ea| attributes.merge(name_column => ea) }
       end
@@ -131,11 +118,9 @@ module ClosureTree
     end
 
     def scoped_attributes(scope, attributes, target_table = model_class.table_name)
-      table_prefixed_attributes = Hash[
-        attributes.map do |column_name, column_value|
-          ["#{target_table}.#{column_name}", column_value]
-        end
-      ]
+      table_prefixed_attributes = attributes.transform_keys do |column_name|
+        "#{target_table}.#{column_name}"
+      end
       scope.where(table_prefixed_attributes)
     end
 
@@ -150,6 +135,7 @@ module ClosureTree
       path.in_groups(max_join_tables, false).each do |subpath|
         child = model_class.find_by_path(subpath, attributes, next_parent_id)
         return nil if child.nil?
+
         next_parent_id = child._ct_id
       end
       child
@@ -168,7 +154,7 @@ module ClosureTree
     end
 
     def create!(model_class, attributes)
-      create(model_class, attributes).tap { |ea| ea.save! }
+      create(model_class, attributes).tap(&:save!)
     end
   end
 end

data/lib/closure_tree/support_attributes.rb

@@ -1,11 +1,37 @@
+# frozen_string_literal: true
+
 require 'forwardable'
+require 'zlib'
+
 module ClosureTree
   module SupportAttributes
     extend Forwardable
     def_delegators :model_class, :connection, :transaction, :table_name, :base_class, :inheritance_column, :column_names
 
     def advisory_lock_name
-      Digest::SHA1.hexdigest("ClosureTree::#{base_class.name}")[0..32]
+      # Allow customization via options or instance method
+      if options[:advisory_lock_name]
+        case options[:advisory_lock_name]
+        when Proc
+          # Allow dynamic generation via proc
+          options[:advisory_lock_name].call(base_class)
+        when Symbol
+          # Allow delegation to a model method
+          if model_class.respond_to?(options[:advisory_lock_name])
+            model_class.send(options[:advisory_lock_name])
+          else
+            raise ArgumentError, "Model #{model_class} does not respond to #{options[:advisory_lock_name]}"
+          end
+        else
+          # Use static string value
+          options[:advisory_lock_name].to_s
+        end
+      else
+        # Default: Use CRC32 for a shorter, consistent hash
+        # This gives us 8 hex characters which is plenty for uniqueness
+        # and leaves room for prefixes
+        "ct_#{Zlib.crc32(base_class.name.to_s).to_s(16)}"
+      end
     end
 
     def quoted_table_name
@@ -17,7 +43,7 @@ module ClosureTree
     end
 
     def hierarchy_class_name
-      options[:hierarchy_class_name] || model_class.to_s + "Hierarchy"
+      options[:hierarchy_class_name] || "#{model_class}Hierarchy"
     end
 
     def primary_key_column
@@ -84,7 +110,7 @@ module ClosureTree
     end
 
     def order_by_order(reverse = false)
-      desc = !!(order_by.to_s =~ /DESC\z/)
+      desc = !(order_by.to_s =~ /DESC\z/).nil?
       desc = !desc if reverse
       desc ? 'DESC' : 'ASC'
     end
@@ -111,13 +137,13 @@ module ClosureTree
 
     def quoted_order_column(include_table_name = true)
       require_order_column
-      prefix = include_table_name ? "#{quoted_table_name}." : ""
+      prefix = include_table_name ? "#{quoted_table_name}." : ''
       "#{prefix}#{connection.quote_column_name(order_column)}"
     end
 
     # table_name alias keyword , like "AS". When used on table name alias, Oracle Database don't support used 'AS'
     def t_alias_keyword
-      (ActiveRecord::Base.connection.adapter_name.to_sym == :OracleEnhanced) ? "" : "AS"
+      ActiveRecord::Base.connection.adapter_name.to_sym == :OracleEnhanced ? '' : 'AS'
     end
   end
 end

data/lib/closure_tree/support_flags.rb

@@ -1,17 +1,7 @@
+# frozen_string_literal: true
+
 module ClosureTree
   module SupportFlags
-
-    def use_attr_accessible?
-      defined?(ActiveModel::MassAssignmentSecurity) &&
-        model_class.respond_to?(:accessible_attributes) &&
-        ! model_class.accessible_attributes.empty?
-    end
-
-    def include_forbidden_attributes_protection?
-      defined?(ActiveModel::ForbiddenAttributesProtection) &&
-        model_class.ancestors.include?(ActiveModel::ForbiddenAttributesProtection)
-    end
-
     def order_option?
       order_by.present?
     end

data/lib/closure_tree/test/matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'closure_tree'
 
 module ClosureTree
@@ -19,13 +21,13 @@ module ClosureTree
             end
 
             # Checking if hierarchy table exists (common error)
-            unless  @subject.hierarchy_class.table_exists?
+            unless @subject.hierarchy_class.table_exists?
               @message = "expected #{@subject.name}'s hierarchy table '#{@subject.hierarchy_class.table_name}' to exist"
               return false
             end
 
             if @ordered
-              unless  @subject._ct.options.include?(:order)
+              unless @subject._ct.options.include?(:order)
                 @message = "expected #{@subject.name} to be an ordered closure tree"
                 return false
               end
@@ -36,13 +38,13 @@ module ClosureTree
             end
 
             if @with_advisory_lock && !@subject._ct.options[:with_advisory_lock]
-                @message = "expected #{@subject.name} to have advisory lock"
-                return false
+              @message = "expected #{@subject.name} to have advisory lock"
+              return false
             end
 
             if @without_advisory_lock && @subject._ct.options[:with_advisory_lock]
-                @message = "expected #{@subject.name} to not have advisory lock"
-                return false
+              @message = "expected #{@subject.name} to not have advisory lock"
+              return false
             end
 
             return true
@@ -70,13 +72,13 @@ module ClosureTree
           @message || "expected #{@subject.name} to #{description}"
         end
 
-        alias_method :failure_message_for_should, :failure_message
+        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "expected #{@subject.name} not be a closure tree, but it is."
         end
 
-        alias_method :failure_message_for_should_not, :failure_message_when_negated
+        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           "be a#{@ordered} closure tree#{@with_advisory_lock}"
@@ -85,7 +87,3 @@ module ClosureTree
     end
   end
 end
-
-RSpec.configure do |c|
-  c.include ClosureTree::Test::Matcher, type: :model
-end

data/lib/closure_tree/version.rb

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

data/lib/closure_tree.rb

@@ -1,30 +1,22 @@
-require 'active_record'
+# frozen_string_literal: true
 
-module ClosureTree
-  extend ActiveSupport::Autoload
+require 'active_record'
+require 'zeitwerk'
 
-  autoload :HasClosureTree
-  autoload :HasClosureTreeRoot
-  autoload :Support
-  autoload :HierarchyMaintenance
-  autoload :Model
-  autoload :Finders
-  autoload :HashTree
-  autoload :Digraphs
-  autoload :DeterministicOrdering
-  autoload :NumericDeterministicOrdering
-  autoload :Configuration
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/generators")
+loader.setup
 
+module ClosureTree
   def self.configure
-    yield configuration
-  end
-
-  def self.configuration
-    @configuration ||= Configuration.new
+    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?
   end
 end
 
-ActiveSupport.on_load :active_record do
-  ActiveRecord::Base.send :extend, ClosureTree::HasClosureTree
-  ActiveRecord::Base.send :extend, ClosureTree::HasClosureTreeRoot
+ActiveSupport.on_load(:active_record) do
+  extend ClosureTree::HasClosureTree, ClosureTree::HasClosureTreeRoot
 end