closure_tree 6.5.0 → 7.3.0

data/lib/closure_tree/has_closure_tree.rb

@@ -8,6 +8,8 @@ module ClosureTree
         :hierarchy_table_name,
         :name_column,
         :order,
+        :dont_order_roots,
+        :numeric_order,
         :touch,
         :with_advisory_lock
       )
@@ -29,6 +31,8 @@ module ClosureTree
 
       include ClosureTree::DeterministicOrdering if _ct.order_option?
       include ClosureTree::NumericDeterministicOrdering if _ct.order_is_numeric?
+
+      connection_pool.release_connection
     rescue StandardError => e
       raise e unless ClosureTree.configuration.database_less
     end

data/lib/closure_tree/has_closure_tree_root.rb

@@ -1,18 +1,14 @@
 module ClosureTree
   class MultipleRootError < StandardError; end
+  class RootOrderingDisabledError < StandardError; end
 
   module HasClosureTreeRoot
 
     def has_closure_tree_root(assoc_name, options = {})
-      options.assert_valid_keys(
-        :class_name,
-        :foreign_key
-      )
-
-      options[:class_name] ||= assoc_name.to_s.sub(/\Aroot_/, "").classify
+       options[:class_name] ||= assoc_name.to_s.sub(/\Aroot_/, "").classify
       options[:foreign_key] ||= self.name.underscore << "_id"
 
-      has_one assoc_name, -> { where(parent: nil) }, options
+      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|
@@ -81,6 +77,8 @@ module ClosureTree
 
         @closure_tree_roots[assoc_name][assoc_map] = root
       end
+
+      connection_pool.release_connection
     end
   end
 end

data/lib/closure_tree/hash_tree_support.rb

@@ -4,17 +4,17 @@ module ClosureTree
         # 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.strip_heredoc
+        generation_depth = <<-SQL.squish
           INNER JOIN (
             SELECT descendant_id, MAX(generations) as depth
             FROM #{quoted_hierarchy_table_name}
             GROUP BY descendant_id
             #{having_clause}
-          ) AS generation_depth
+          ) #{ 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')
-      end
+    end
 
     def hash_tree(tree_scope, limit_depth = nil)
       limited_scope = limit_depth ? tree_scope.where("#{quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}") : tree_scope
@@ -33,4 +33,4 @@ module ClosureTree
       tree
     end
   end
-end
+end

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -20,7 +20,7 @@ module ClosureTree
     end
 
     def _ct_validate
-      if !@_ct_skip_cycle_detection &&
+      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
@@ -35,10 +35,13 @@ module ClosureTree
     end
 
     def _ct_after_save
-      if changes[_ct.parent_column_name] || @was_new_record
+      as_5_1 = ActiveSupport.version >= Gem::Version.new('5.1.0')
+      changes_method = as_5_1 ? :saved_changes : :changes
+
+      if public_send(changes_method)[_ct.parent_column_name] || @was_new_record
         rebuild!
       end
-      if changes[_ct.parent_column_name] && !@was_new_record
+      if public_send(changes_method)[_ct.parent_column_name] && !@was_new_record
         # Resetting the ancestral collections addresses
         # https://github.com/mceachen/closure_tree/issues/68
         ancestor_hierarchies.reload
@@ -61,10 +64,10 @@ module ClosureTree
 
     def rebuild!(called_by_rebuild = false)
       _ct.with_advisory_lock do
-        delete_hierarchy_references unless @was_new_record
+        delete_hierarchy_references unless (defined? @was_new_record) && @was_new_record
         hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
         unless root?
-          _ct.connection.execute <<-SQL.strip_heredoc
+          _ct.connection.execute <<-SQL.squish
             INSERT INTO #{_ct.quoted_hierarchy_table_name}
               (ancestor_id, descendant_id, generations)
             SELECT x.ancestor_id, #{_ct.quote(_ct_id)}, x.generations + 1
@@ -91,7 +94,7 @@ 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.strip_heredoc
+        _ct.connection.execute <<-SQL.squish
           DELETE FROM #{_ct.quoted_hierarchy_table_name}
           WHERE descendant_id IN (
             SELECT DISTINCT descendant_id
@@ -99,7 +102,7 @@ module ClosureTree
               FROM #{_ct.quoted_hierarchy_table_name}
               WHERE ancestor_id = #{_ct.quote(id)}
                  OR descendant_id = #{_ct.quote(id)}
-            ) AS x )
+            ) #{ _ct.t_alias_keyword } x )
         SQL
       end
     end
@@ -109,11 +112,28 @@ module ClosureTree
       # Note that the hierarchy table will be truncated.
       def rebuild!
         _ct.with_advisory_lock do
-          hierarchy_class.delete_all # not destroy_all -- we just want a simple truncate.
+          cleanup!
           roots.find_each { |n| n.send(:rebuild!) } # roots just uses the parent_id column, so this is safe.
         end
         nil
       end
+
+      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"
+          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]))
+                                     .join_sources
+
+          lonely_childs = hierarchy_class.joins(arel_join).where(alias_table[primary_key].eq(nil))
+          ids = lonely_childs.pluck(foreign_key)
+
+          hierarchy_class.where(hierarchy_table[foreign_key].in(ids)).delete_all
+        end
+      end
     end
   end
 end

data/lib/closure_tree/model.rb

@@ -6,20 +6,20 @@ module ClosureTree
 
     included do
 
-      belongs_to :parent, nil, *_ct.belongs_to_with_optional_option(
+      belongs_to :parent, nil, **_ct.belongs_to_with_optional_option(
         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 = "#{_ct.quoted_hierarchy_table_name}.generations asc"
+      order_by_generations = -> { Arel.sql("#{_ct.quoted_hierarchy_table_name}.generations ASC") }
 
-      has_many :children, *_ct.has_many_with_order_option(
+      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
+        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.
@@ -28,25 +28,21 @@ module ClosureTree
           end
         end
 
-      has_many :ancestor_hierarchies, *_ct.has_many_without_order_option(
+      has_many :ancestor_hierarchies, *_ct.has_many_order_without_option(order_by_generations),
         class_name: _ct.hierarchy_class_name,
-        foreign_key: 'descendant_id',
-        order: order_by_generations)
+        foreign_key: 'descendant_id'
 
-      has_many :self_and_ancestors, *_ct.has_many_without_order_option(
+      has_many :self_and_ancestors, *_ct.has_many_order_without_option(order_by_generations),
         through: :ancestor_hierarchies,
-        source: :ancestor,
-        order: order_by_generations)
+        source: :ancestor
 
-      has_many :descendant_hierarchies, *_ct.has_many_without_order_option(
+      has_many :descendant_hierarchies, *_ct.has_many_order_without_option(order_by_generations),
         class_name: _ct.hierarchy_class_name,
-        foreign_key: 'ancestor_id',
-        order: order_by_generations)
+        foreign_key: 'ancestor_id'
 
-      has_many :self_and_descendants, *_ct.has_many_with_order_option(
+      has_many :self_and_descendants, *_ct.has_many_order_with_option(order_by_generations),
         through: :descendant_hierarchies,
-        source: :descendant,
-        order: order_by_generations)
+        source: :descendant
     end
 
     # Delegate to the Support instance on the class:
@@ -134,6 +130,36 @@ module ClosureTree
       _ct.ids_from(siblings)
     end
 
+    # node's parent is this record
+    def parent_of?(node)
+      self == node.parent
+    end
+
+    # node's root is this record
+    def root_of?(node)
+      self == node.root
+    end
+
+    # node's ancestors include this record
+    def ancestor_of?(node)
+      node.ancestors.include? self
+    end
+
+    # node is record's ancestor
+    def descendant_of?(node)
+      self.ancestors.include? node
+    end
+
+    # node is record's parent
+    def child_of?(node)
+      self.parent == node
+    end
+
+    # node and record have a same root
+    def family_of?(node)
+      self.root == node.root
+    end
+
     # Alias for appending to the children collection.
     # You can also add directly to the children collection, if you'd prefer.
     def add_child(child_node)

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -10,8 +10,13 @@ module ClosureTree
     end
 
     def _ct_reorder_prior_siblings_if_parent_changed
-      if attribute_changed?(_ct.parent_column_name) && !@was_new_record
-        was_parent_id = attribute_was(_ct.parent_column_name)
+      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
+
+        was_parent_id = public_send(attribute_method, _ct.parent_column_name)
         _ct.reorder_with_parent_id(was_parent_id)
       end
     end
@@ -46,7 +51,7 @@ module ClosureTree
 
       # If node is nil, order the whole tree.
       def _ct_sum_order_by(node = nil)
-        stats_sql = <<-SQL.strip_heredoc
+        stats_sql = <<-SQL.squish
           SELECT
             count(*) as total_descendants,
             max(generations) as max_depth
@@ -60,11 +65,16 @@ module ClosureTree
         node_score = "(1 + anc.#{_ct.quoted_order_column(false)}) * " +
           "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - #{depth_column})"
 
-        "sum(#{node_score})"
+        # 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
-        join_sql = <<-SQL.strip_heredoc
+        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
@@ -73,7 +83,7 @@ module ClosureTree
             SELECT descendant_id, max(generations) AS max_depth
             FROM #{_ct.quoted_hierarchy_table_name}
             GROUP BY descendant_id
-          ) AS depths ON depths.descendant_id = anc.#{_ct.quoted_id_column_name}
+          ) #{ _ct.t_alias_keyword } depths ON depths.descendant_id = anc.#{_ct.quoted_id_column_name}
         SQL
         joins(join_sql)
           .group("#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name}")
@@ -108,6 +118,10 @@ module ClosureTree
     def add_sibling(sibling, add_after = true)
       fail "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")
+      end
+
       # Make sure self isn't dirty, because we're going to call reload:
       save
 

data/lib/closure_tree/numeric_order_support.rb

@@ -14,13 +14,14 @@ 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
         connection.execute 'SET @i = 0'
-        connection.execute <<-SQL.strip_heredoc
+        connection.execute <<-SQL.squish
           UPDATE #{quoted_table_name}
             SET #{quoted_order_column} = (@i := @i + 1) + #{minimum_sort_order_value.to_i - 1}
           WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}
@@ -31,12 +32,13 @@ 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
-        connection.execute <<-SQL.strip_heredoc
+        connection.execute <<-SQL.squish
           UPDATE #{quoted_table_name}
           SET #{quoted_order_column(false)} = t.seq + #{minimum_sort_order_value.to_i - 1}
           FROM (
@@ -44,7 +46,8 @@ module ClosureTree
             FROM #{quoted_table_name}
             WHERE #{where_eq(parent_column_name, parent_id)} #{min_where}
           ) AS t
-          WHERE #{quoted_table_name}.#{quoted_id_column_name} = t.id
+          WHERE #{quoted_table_name}.#{quoted_id_column_name} = t.id and
+                #{quoted_table_name}.#{quoted_order_column(false)} is distinct from t.seq + #{minimum_sort_order_value.to_i - 1}
         SQL
       end
 
@@ -55,6 +58,7 @@ 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)

data/lib/closure_tree/support.rb

@@ -22,7 +22,8 @@ module ClosureTree
         :parent_column_name => 'parent_id',
         :dependent => :nullify, # or :destroy or :delete_all -- see the README
         :name_column => 'name',
-        :with_advisory_lock => true
+        :with_advisory_lock => true,
+        :numeric_order => false
       }.merge(options)
       raise ArgumentError, "name_column can't be 'path'" if options[:name_column] == 'path'
       if order_is_numeric?
@@ -31,13 +32,15 @@ module ClosureTree
     end
 
     def hierarchy_class_for_model
-      hierarchy_class = model_class.parent.const_set(short_hierarchy_class_name, Class.new(ActiveRecord::Base))
+      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?
-      hierarchy_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      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}"
-        belongs_to :descendant, :class_name => "#{model_class}"
+        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
@@ -46,7 +49,7 @@ module ClosureTree
         def hash
           ancestor_id.hash << 31 ^ descendant_id.hash
         end
-      RUBY
+      end
       hierarchy_class.table_name = hierarchy_table_name
       hierarchy_class
     end
@@ -77,17 +80,20 @@ module ClosureTree
     end
 
     def belongs_to_with_optional_option(opts)
-      [ActiveRecord::VERSION::MAJOR < 5 ? opts.except(:optional) : 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_without_order_option(opts)
-        [lambda { order(opts[:order]) }, opts.except(:order)]
+    def has_many_order_without_option(order_by_opt)
+      [lambda { order(order_by_opt.call) }]
     end
 
-    def has_many_with_order_option(opts)
-      order_options = [opts[:order], order_by].compact
-      [lambda { order(order_options) }, opts.except(:order)]
+    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 }
+        order(order_options)
+      }]
     end
 
     def ids_from(scope)

data/lib/closure_tree/support_attributes.rb

@@ -75,8 +75,12 @@ module ClosureTree
       options[:order]
     end
 
+    def dont_order_roots
+      options[:dont_order_roots] || false
+    end
+
     def nulls_last_order_by
-      "-#{quoted_order_column} #{order_by_order(reverse = true)}"
+      Arel.sql "-#{quoted_order_column} #{order_by_order(true)}"
     end
 
     def order_by_order(reverse = false)
@@ -110,5 +114,10 @@ module ClosureTree
       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"
+    end
   end
 end