support hash_tree from relations

Author: mceachen

lib/closure_tree/active_record_support.rb

@@ -1,5 +1,10 @@
 module ClosureTree
   module ActiveRecordSupport
+
+    def quote(field)
+      connection.quote(field)
+    end
+
     def ensure_fixed_table_name(table_name)
       [
         ActiveRecord::Base.table_name_prefix,

lib/closure_tree/hash_tree.rb

@@ -2,57 +2,16 @@ module ClosureTree
   module HashTree
     extend ActiveSupport::Concern
 
-    def hash_tree_scope(limit_depth = nil)
-      scope = self_and_descendants
-      if limit_depth
-        scope.where("#{_ct.quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}")
-      else
-        scope
-      end
-    end
-
     def hash_tree(options = {})
-      self.class.build_hash_tree(hash_tree_scope(options[:limit_depth]))
+      _ct.hash_tree(self_and_descendants, options[:limit_depth])
     end
 
     module ClassMethods
 
       # 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 = {})
-        build_hash_tree(hash_tree_scope(options[:limit_depth]))
-      end
-
-      def hash_tree_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.strip_heredoc
-          INNER JOIN (
-            SELECT descendant_id, MAX(generations) as depth
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY descendant_id
-            #{having_clause}
-          ) AS generation_depth
-            ON #{_ct.quoted_table_name}.#{primary_key} = generation_depth.descendant_id
-        SQL
-        _ct.scope_with_order(joins(generation_depth), "generation_depth.depth")
-      end
-
-      # Builds nested hash structure using the scope returned from the passed in scope
-      def build_hash_tree(tree_scope)
-        tree = ActiveSupport::OrderedHash.new
-        id_to_hash = {}
-
-        tree_scope.each do |ea|
-          h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
-          if ea.root? || tree.empty? # We're at the top of the tree.
-            tree[ea] = h
-          else
-            id_to_hash[ea._ct_parent_id][ea] = h
-          end
-        end
-        tree
+        _ct.hash_tree(nil, options[:limit_depth])
       end
     end
   end

lib/closure_tree/hash_tree_support.rb

@@ -0,0 +1,40 @@
+module ClosureTree
+  module HashTreeSupport
+    def default_tree_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.strip_heredoc
+          INNER JOIN (
+            SELECT descendant_id, MAX(generations) as depth
+            FROM #{quoted_hierarchy_table_name}
+            GROUP BY descendant_id
+            #{having_clause}
+          ) AS generation_depth
+            ON #{quoted_table_name}.#{model_class.primary_key} = generation_depth.descendant_id
+        SQL
+        scope_with_order(model_class.joins(generation_depth), 'generation_depth.depth')
+      end
+
+    def hash_tree(tree_scope, limit_depth = nil)
+      limited_scope = if tree_scope
+        limit_depth ? tree_scope.where("#{quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}") : tree_scope
+      else
+        default_tree_scope(limit_depth)
+      end
+      build_hash_tree(limited_scope)
+    end
+
+    # Builds nested hash structure using the scope returned from the passed in scope
+    def build_hash_tree(tree_scope)
+      tree = ActiveSupport::OrderedHash.new
+      id_to_hash = {}
+
+      tree_scope.each do |ea|
+        h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
+        (id_to_hash[ea._ct_parent_id] || tree)[ea] = h
+      end
+      tree
+    end
+  end
+end

lib/closure_tree/model.rb

@@ -17,7 +17,14 @@ module Model
         class_name: _ct.model_class.to_s,
         foreign_key: _ct.parent_column_name,
         dependent: _ct.options[:dependent],
-        inverse_of: :parent)
+        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_without_order_option(
         class_name: _ct.hierarchy_class_name,

lib/closure_tree/support.rb

@@ -2,6 +2,7 @@
 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'
 
 # This class and mixins are an effort to reduce the namespace pollution to models that act_as_tree.
@@ -10,6 +11,7 @@ class Support
     include ClosureTree::SupportFlags
     include ClosureTree::SupportAttributes
     include ClosureTree::ActiveRecordSupport
+    include ClosureTree::HashTreeSupport
 
     attr_reader :model_class
     attr_reader :options
@@ -59,10 +61,6 @@ def hierarchy_table_name
       ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
     end
 
-    def quote(field)
-      connection.quote(field)
-    end
-
     def with_order_option(opts)
       if order_option?
         opts[:order] = [opts[:order], order_by].compact.join(",")