closure_tree 4.1.0 → 4.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWJmNzNmNzk4OGM2YmJlYWIzYjdkNTE2Yzk2YjZlNWM1ZDgwMTlhYg==
+  data.tar.gz: !binary |-
+    YjcwMmY4MTcwMTRlZmJmODAwOGViNGMyNzU4NGQ5MGY4ZDU1MjQ5Mg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NGRlYjk1MDU4NzdiYzQzNzIzZGQxZTZjMjc1NDA4NzQ0YTAwYTExYTZlM2E4
+    YWM0OTY4NzQ2ZmI4NjA2NDc4MWNjN2RlODIwNTY0ZWMwZGJmNzUwNjk0ZmE3
+    M2NlYmU1MTk5MzViN2ExZmIwYjBmYTU5N2JhMGVmOGE5N2U3NmQ=
+  data.tar.gz: !binary |-
+    NmE0NGFjNmZiMDAwM2U5MTc3Y2E3OWIyMGFiNTEzYWI3MTA1MmRlYWI5MzQw
+    OGMxNGQwODZmY2ZiNzQwZDhmNGUzYTEwNjNkMTZlOTNjZTE5ZTA2NGNhNTg5
+    MTJjMjgxODk1NzdmOWQ1NzhhODA1MWZhYjNlYzUyOGUxNmVlYTk=

data/README.md

@@ -7,6 +7,7 @@ and tracking user referrals.
 
 [![Build Status](https://secure.travis-ci.org/mceachen/closure_tree.png?branch=master)](http://travis-ci.org/mceachen/closure_tree)
 [![Gem Version](https://badge.fury.io/rb/closure_tree.png)](http://rubygems.org/gems/closure_tree)
+[![Code Climate](https://codeclimate.com/github/mceachen/closure_tree.png)](https://codeclimate.com/github/mceachen/closure_tree)
 
 Substantially more efficient than
 [ancestry](https://github.com/stefankroes/ancestry) and
@@ -156,7 +157,8 @@ Ancestry paths may be built using any column in your model. The default
 column is ```name```, which can be changed with the :name_column option
 provided to ```acts_as_tree```.
 
-Note that any other AR fields can be set with the second, optional ```attributes``` argument.
+Note that any other AR fields can be set with the second, optional ```attributes``` argument,
+and as of version 4.2.0, these attributes are added to the where clause as selection criteria.
 
 ```ruby
 child = Tag.find_or_create_by_path(%w{home chuck Photos"}, {:tag_type => "File"})
@@ -252,9 +254,10 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
 * ```Tag.roots``` returns all root nodes
 * ```Tag.leaves``` returns all leaf nodes
 * ```Tag.hash_tree``` returns an [ordered, nested hash](#nested-hashes) that can be depth-limited.
-* ```Tag.find_by_path(path)``` returns the node whose name path is ```path```. See (#find_or_create_by_path).
-* ```Tag.find_or_create_by_path(path)``` returns the node whose name path is ```path```, and will create the node if it doesn't exist already.See (#find_or_create_by_path).
+* ```Tag.find_by_path(path, attributes)``` returns the node whose name path is ```path```. See (#find_or_create_by_path).
+* ```Tag.find_or_create_by_path(path, attributes)``` returns the node whose name path is ```path```, and will create the node if it doesn't exist already.See (#find_or_create_by_path).
 * ```Tag.find_all_by_generation(generation_level)``` returns the descendant nodes who are ```generation_level``` away from a root. ```Tag.find_all_by_generation(0)``` is equivalent to ```Tag.roots```.
+* ```Tag.with_ancestor(ancestors)``` scopes to all descendants whose ancestor is in the given list.
 
 ### Instance methods
 
@@ -468,6 +471,15 @@ Parallelism is not tested with Rails 3.0.x nor 3.1.x due to this
 
 ## Change log
 
+### 4.2.0
+
+* Added ```with_ancestor(*ancestors)```. Thanks for the idea, [Matt](https://github.com/mgornick)!
+* Applied [Leonel Galan](https://github.com/leonelgalan)'s fix for Strong Attribute support
+* ```find_or_create_by``` now uses passed-in attributes as both selection and creation criteria.
+  Thanks for the help, [Judd Blair](https://github.com/juddblair)!
+  **Please note that this changes prior behavior—test your code with this new version!**
+* ```ct_advisory_lock``` was moved into the ```_ct``` support class, to reduce model method pollution
+
 ### 4.1.0
 
 * Added support for Rails 4.0.0.rc1 and Ruby 2.0.0 (while maintaining backward compatibility with Rails 3, BOOYA)

data/lib/closure_tree/acts_as_tree.rb

@@ -1,8 +1,12 @@
+require 'with_advisory_lock'
 require 'closure_tree/support'
+require 'closure_tree/hierarchy_maintenance'
 require 'closure_tree/model'
+require 'closure_tree/finders'
+require 'closure_tree/hash_tree'
+require 'closure_tree/digraphs'
 require 'closure_tree/deterministic_ordering'
 require 'closure_tree/numeric_deterministic_ordering'
-require 'closure_tree/with_advisory_lock'
 
 module ClosureTree
   module ActsAsTree
@@ -15,13 +19,15 @@ module ClosureTree
       class_attribute :hierarchy_class
       self.hierarchy_class = _ct.hierarchy_class_for_model
 
+      # tests fail if you include Model before HierarchyMaintenance wtf
+      include ClosureTree::HierarchyMaintenance
       include ClosureTree::Model
-      include ClosureTree::WithAdvisoryLock
+      include ClosureTree::Finders
+      include ClosureTree::HashTree
+      include ClosureTree::Digraphs
 
-      if _ct.order_option?
-        include ClosureTree::DeterministicOrdering
-        include ClosureTree::DeterministicNumericOrdering if _ct.order_is_numeric?
-      end
+      include ClosureTree::DeterministicOrdering if _ct.order_option?
+      include ClosureTree::NumericDeterministicOrdering if _ct.order_is_numeric?
     end
   end
 end

data/lib/closure_tree/digraphs.rb

@@ -0,0 +1,31 @@
+module ClosureTree
+  module Digraphs
+    extend ActiveSupport::Concern
+
+    def to_dot_digraph
+      self.class.to_dot_digraph(self_and_descendants)
+    end
+
+    # override this method in your model class if you want a different digraph label.
+    def to_digraph_label
+      _ct.has_name? ? read_attribute(_ct.name_column) : to_s
+    end
+
+    module ClassMethods
+      # Renders the given scope as a DOT digraph, suitable for rendering by Graphviz
+      def to_dot_digraph(tree_scope)
+        id_to_instance = tree_scope.inject({}) { |h, ea| h[ea.id] = ea; h }
+        output = StringIO.new
+        output << "digraph G {\n"
+        tree_scope.each do |ea|
+          if id_to_instance.has_key? ea._ct_parent_id
+            output << "  #{ea._ct_parent_id} -> #{ea._ct_id}\n"
+          end
+          output << "  #{ea._ct_id} [label=\"#{ea.to_digraph_label}\"]\n"
+        end
+        output << "}\n"
+        output.string
+      end
+    end
+  end
+end

data/lib/closure_tree/finders.rb

@@ -0,0 +1,152 @@
+module ClosureTree
+  module Finders
+    extend ActiveSupport::Concern
+
+    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
+    def find_by_path(path, attributes = {})
+      return self if path.empty?
+      self.class.find_by_path(path, attributes, id)
+    end
+
+    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
+    def find_or_create_by_path(path, attributes = {}, find_before_lock = true)
+      attributes[:type] ||= self.type if _ct.subclass? && _ct.has_type?
+      (find_before_lock && find_by_path(path, attributes)) || begin
+        _ct.with_advisory_lock do
+          subpath = path.is_a?(Enumerable) ? path.dup : [path]
+          child_name = subpath.shift
+          return self unless child_name
+          child = transaction do
+            attrs = attributes.merge(_ct.name_sym => child_name)
+            # shenanigans because children.create is bound to the superclass
+            # (in the case of polymorphism):
+            self.children.where(attrs).first || begin
+              self.class.new(attrs).tap { |ea| self.children << ea }
+            end
+          end
+          child.find_or_create_by_path(subpath, attributes, false)
+        end
+      end
+    end
+
+    def find_all_by_generation(generation_level)
+      s = _ct.base_class.joins(<<-SQL)
+        INNER JOIN (
+          SELECT descendant_id
+          FROM #{_ct.quoted_hierarchy_table_name}
+          WHERE ancestor_id = #{_ct.quote(self.id)}
+          GROUP BY 1
+          HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
+        ) AS descendants ON (#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} = descendants.descendant_id)
+      SQL
+      _ct.scope_with_order(s)
+    end
+
+    def without_self(scope)
+      scope.without(self)
+    end
+
+    module ClassMethods
+
+      def without(instance)
+        if instance.new_record?
+          all
+        else
+          where(["#{_ct.quoted_table_name}.#{_ct.quoted_id_column_name} != ?", instance.id])
+        end
+      end
+
+      def roots
+        _ct.scope_with_order(where(_ct.parent_column_name => nil))
+      end
+
+      # Returns an arbitrary node that has no parents.
+      def root
+        roots.first
+      end
+
+      def leaves
+        s = joins(<<-SQL)
+          INNER JOIN (
+            SELECT ancestor_id
+            FROM #{_ct.quoted_hierarchy_table_name}
+            GROUP BY 1
+            HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = 0
+          ) AS leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
+        SQL
+        _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? ? scoped : joins(:ancestor_hierarchies).
+          where("#{_ct.hierarchy_table_name}.ancestor_id" => ancestor_ids).
+          where("#{_ct.hierarchy_table_name}.generations > 0").
+          readonly(false)
+        _ct.scope_with_order(scope)
+      end
+
+      def find_all_by_generation(generation_level)
+        s = joins(<<-SQL)
+          INNER JOIN (
+            SELECT #{primary_key} as root_id
+            FROM #{_ct.quoted_table_name}
+            WHERE #{_ct.quoted_parent_column_name} IS NULL
+          ) AS roots ON (1 = 1)
+          INNER JOIN (
+            SELECT ancestor_id, descendant_id
+            FROM #{_ct.quoted_hierarchy_table_name}
+            GROUP BY 1, 2
+            HAVING MAX(generations) = #{generation_level.to_i}
+          ) AS descendants ON (
+            #{_ct.quoted_table_name}.#{primary_key} = descendants.descendant_id
+            AND roots.root_id = descendants.ancestor_id
+          )
+        SQL
+        _ct.scope_with_order(s)
+      end
+
+      def ct_scoped_attributes(scope, attributes, target_table = table_name)
+        attributes.inject(scope) do |scope, pair|
+          scope.where("#{target_table}.#{pair.first}" => pair.last)
+        end
+      end
+
+      # Find the node whose +ancestry_path+ is +path+
+      def find_by_path(path, attributes = {}, parent_id = nil)
+        path = path.is_a?(Enumerable) ? path.dup : [path]
+        scope = where(_ct.name_sym => path.pop).readonly(false)
+        scope = ct_scoped_attributes(scope, attributes)
+        last_joined_table = _ct.table_name
+        path.reverse.each_with_index do |ea, idx|
+          next_joined_table = "p#{idx}"
+          scope = scope.joins(<<-SQL)
+            INNER JOIN #{_ct.quoted_table_name} AS #{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 = scope.where("#{next_joined_table}.#{_ct.name_column}" => ea)
+          scope = ct_scoped_attributes(scope, attributes, next_joined_table)
+          last_joined_table = next_joined_table
+        end
+        scope = scope.where("#{last_joined_table}.#{_ct.parent_column_name}" => parent_id)
+        scope.first
+      end
+
+      # Find or create nodes such that the +ancestry_path+ is +path+
+      def find_or_create_by_path(path, attributes = {})
+        find_by_path(path, attributes) || begin
+          subpath = path.dup
+          root_name = subpath.shift
+          _ct.with_advisory_lock do
+            # shenanigans because find_or_create can't infer that we want the same class as this:
+            # Note that roots will already be constrained to this subclass (in the case of polymorphism):
+            attrs = attributes.merge(_ct.name_sym => root_name)
+            root = roots.where(attrs).first || roots.create!(attrs)
+            root.find_or_create_by_path(subpath, attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/closure_tree/hash_tree.rb

@@ -0,0 +1,59 @@
+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]))
+    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
+          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
+      end
+    end
+  end
+end

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -0,0 +1,87 @@
+require 'active_support/concern'
+
+module ClosureTree
+  module HierarchyMaintenance
+    extend ActiveSupport::Concern
+
+    included do
+      validate :_ct_validate
+      before_save :_ct_before_save
+      after_save :_ct_after_save
+      before_destroy :_ct_before_destroy
+    end
+
+    def _ct_validate
+      if changes[_ct.parent_column_name] &&
+        parent.present? &&
+        parent.self_and_ancestors.include?(self)
+        errors.add(_ct.parent_column_sym, "You cannot add an ancestor as a descendant")
+      end
+    end
+
+    def _ct_before_save
+      @was_new_record = new_record?
+      true # don't cancel the save
+    end
+
+    def _ct_after_save
+      rebuild! if changes[_ct.parent_column_name] || @was_new_record
+      @was_new_record = false # we aren't new anymore.
+      true # don't cancel anything.
+    end
+
+    def _ct_before_destroy
+      delete_hierarchy_references
+      if _ct.options[:dependent] == :nullify
+        self.class.find(self.id).children.each { |c| c.rebuild! }
+      end
+      true # don't prevent destruction
+    end
+
+    def rebuild!
+      _ct.with_advisory_lock do
+        delete_hierarchy_references unless @was_new_record
+        hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
+        unless root?
+          _ct.connection.execute <<-SQL
+            INSERT INTO #{_ct.quoted_hierarchy_table_name}
+              (ancestor_id, descendant_id, generations)
+            SELECT x.ancestor_id, #{_ct.quote(_ct_id)}, x.generations + 1
+            FROM #{_ct.quoted_hierarchy_table_name} x
+            WHERE x.descendant_id = #{_ct.quote(_ct_parent_id)}
+          SQL
+        end
+        children.each { |c| c.rebuild! }
+      end
+    end
+
+    def delete_hierarchy_references
+      # The crazy double-wrapped sub-subselect works around MySQL's limitation of subselects on the same table that is being mutated.
+      # 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
+        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)}
+          ) AS x )
+          OR descendant_id = #{_ct.quote(id)}
+      SQL
+    end
+
+    module ClassMethods
+      # Rebuilds the hierarchy table based on the parent_id column in the database.
+      # 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.
+          roots.each { |n| n.send(:rebuild!) } # roots just uses the parent_id column, so this is safe.
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/closure_tree/model.rb

@@ -5,11 +5,6 @@ module ClosureTree
     extend ActiveSupport::Concern
 
     included do
-      validate :_ct_validate
-      before_save :_ct_before_save
-      after_save :_ct_after_save
-      before_destroy :_ct_before_destroy
-
       belongs_to :parent,
         :class_name => _ct.model_class.to_s,
         :foreign_key => _ct.parent_column_name
@@ -45,14 +40,6 @@ module ClosureTree
         :through => :descendant_hierarchies,
         :source => :descendant,
         :order => order_by_generations)
-
-      scope :without, lambda { |instance|
-        if instance.new_record?
-          all
-        else
-          where(["#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} != ?", instance.id])
-        end
-      }
     end
 
     # Delegate to the Support instance on the class:
@@ -136,65 +123,6 @@ module ClosureTree
       child_node
     end
 
-    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
-    def find_by_path(path)
-      return self if path.empty?
-      parent_constraint = "#{_ct.quoted_parent_column_name} = #{_ct.quote(id)}"
-      self.class.ct_scoped_to_path(path, parent_constraint).first
-    end
-
-    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
-    def find_or_create_by_path(path, attributes = {}, find_before_lock = true)
-      (find_before_lock && find_by_path(path)) || begin
-        ct_with_advisory_lock do
-          subpath = path.is_a?(Enumerable) ? path.dup : [path]
-          child_name = subpath.shift
-          return self unless child_name
-          child = transaction do
-            attrs = {_ct.name_sym => child_name}
-            attrs[:type] = self.type if _ct.subclass? && _ct.has_type?
-            self.children.where(attrs).first || begin
-              child = self.class.new(attributes.merge(attrs))
-              self.children << child
-              child
-            end
-          end
-          child.find_or_create_by_path(subpath, attributes, false)
-        end
-      end
-    end
-
-    def find_all_by_generation(generation_level)
-      s = _ct.base_class.joins(<<-SQL)
-        INNER JOIN (
-          SELECT descendant_id
-          FROM #{_ct.quoted_hierarchy_table_name}
-          WHERE ancestor_id = #{_ct.quote(self.id)}
-          GROUP BY 1
-          HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
-        ) AS descendants ON (#{_ct.quoted_table_name}.#{_ct.base_class.primary_key} = descendants.descendant_id)
-      SQL
-      _ct.scope_with_order(s)
-    end
-
-    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]))
-    end
-
-    # override this method in your model class if you want a different digraph label.
-    def to_digraph_label
-      _ct.has_name? ? read_attribute(_ct.name_column) : to_s
-    end
-
     def _ct_parent_id
       read_attribute(_ct.parent_column_sym)
     end
@@ -202,216 +130,5 @@ module ClosureTree
     def _ct_id
       read_attribute(_ct.model_class.primary_key)
     end
-
-    def _ct_validate
-      if changes[_ct.parent_column_name] &&
-        parent.present? &&
-        parent.self_and_ancestors.include?(self)
-        errors.add(_ct.parent_column_sym, "You cannot add an ancestor as a descendant")
-      end
-    end
-
-    def _ct_before_save
-      @was_new_record = new_record?
-      true # don't cancel the save
-    end
-
-    def _ct_after_save
-      rebuild! if changes[_ct.parent_column_name] || @was_new_record
-      @was_new_record = false # we aren't new anymore.
-      true # don't cancel anything.
-    end
-
-    def rebuild!
-      ct_with_advisory_lock do
-        delete_hierarchy_references unless @was_new_record
-        hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
-        unless root?
-          sql = <<-SQL
-            INSERT INTO #{_ct.quoted_hierarchy_table_name}
-              (ancestor_id, descendant_id, generations)
-            SELECT x.ancestor_id, #{_ct.quote(_ct_id)}, x.generations + 1
-            FROM #{_ct.quoted_hierarchy_table_name} x
-            WHERE x.descendant_id = #{_ct.quote(_ct_parent_id)}
-          SQL
-          _ct.connection.execute sql.strip
-        end
-        children.each { |c| c.rebuild! }
-      end
-    end
-
-    def _ct_before_destroy
-      delete_hierarchy_references
-      if _ct.options[:dependent] == :nullify
-        children.each { |c| c.rebuild! }
-      end
-    end
-
-    def delete_hierarchy_references
-      # The crazy double-wrapped sub-subselect works around MySQL's limitation of subselects on the same table that is being mutated.
-      # 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
-        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)}
-          ) AS x )
-          OR descendant_id = #{_ct.quote(id)}
-      SQL
-    end
-
-    def without_self(scope)
-      scope.without(self)
-    end
-
-    def to_dot_digraph
-      self.class.to_dot_digraph(self_and_descendants)
-    end
-
-    module ClassMethods
-      def roots
-        _ct.scope_with_order(where(_ct.parent_column_name => nil))
-      end
-
-      # Returns an arbitrary node that has no parents.
-      def root
-        roots.first
-      end
-
-      # 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 leaves
-        s = joins(<<-SQL)
-          INNER JOIN (
-            SELECT ancestor_id
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY 1
-            HAVING MAX(#{_ct.quoted_hierarchy_table_name}.generations) = 0
-          ) AS leaves ON (#{_ct.quoted_table_name}.#{primary_key} = leaves.ancestor_id)
-        SQL
-        _ct.scope_with_order(s.readonly(false))
-      end
-
-      # Rebuilds the hierarchy table based on the parent_id column in the database.
-      # 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.
-          roots.each { |n| n.send(:rebuild!) } # roots just uses the parent_id column, so this is safe.
-        end
-        nil
-      end
-
-      def find_all_by_generation(generation_level)
-        s = joins(<<-SQL)
-          INNER JOIN (
-            SELECT #{primary_key} as root_id
-            FROM #{_ct.quoted_table_name}
-            WHERE #{_ct.quoted_parent_column_name} IS NULL
-          ) AS roots ON (1 = 1)
-          INNER JOIN (
-            SELECT ancestor_id, descendant_id
-            FROM #{_ct.quoted_hierarchy_table_name}
-            GROUP BY 1, 2
-            HAVING MAX(generations) = #{generation_level.to_i}
-          ) AS descendants ON (
-            #{_ct.quoted_table_name}.#{primary_key} = descendants.descendant_id
-            AND roots.root_id = descendants.ancestor_id
-          )
-        SQL
-        _ct.scope_with_order(s)
-      end
-
-      # Find the node whose +ancestry_path+ is +path+
-      def find_by_path(path)
-        parent_constraint = "#{_ct.quoted_parent_column_name} IS NULL"
-        ct_scoped_to_path(path, parent_constraint).first
-      end
-
-      def ct_scoped_to_path(path, parent_constraint)
-        path = path.is_a?(Enumerable) ? path.dup : [path]
-        scope = where(_ct.name_sym => path.last).readonly(false)
-        path[0..-2].reverse.each_with_index do |ea, idx|
-          subtable = idx == 0 ? _ct.quoted_table_name : "p#{idx - 1}"
-          scope = scope.joins(<<-SQL)
-            INNER JOIN #{_ct.quoted_table_name} AS p#{idx}
-              ON p#{idx}.#{_ct.quoted_id_column_name} = #{subtable}.#{_ct.parent_column_name}
-          SQL
-          scope = scope.where("p#{idx}.#{_ct.quoted_name_column} = #{_ct.quote(ea)}")
-        end
-        root_table_name = path.size > 1 ? "p#{path.size - 2}" : _ct.quoted_table_name
-        scope.where("#{root_table_name}.#{parent_constraint}")
-      end
-
-      # Find or create nodes such that the +ancestry_path+ is +path+
-      def find_or_create_by_path(path, attributes = {})
-        find_by_path(path) || begin
-          subpath = path.dup
-          root_name = subpath.shift
-          ct_with_advisory_lock do
-            # shenanigans because find_or_create can't infer we want the same class as this:
-            # Note that roots will already be constrained to this subclass (in the case of polymorphism):
-            root = roots.where(_ct.name_sym => root_name).first
-            root ||= create!(attributes.merge(_ct.name_sym => root_name))
-            root.find_or_create_by_path(subpath, attributes)
-          end
-        end
-      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
-          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
-      end
-
-      # Renders the given scope as a DOT digraph, suitable for rendering by Graphviz
-      def to_dot_digraph(tree_scope)
-        id_to_instance = tree_scope.inject({}) { |h, ea| h[ea.id] = ea; h }
-        output = StringIO.new
-        output << "digraph G {\n"
-        tree_scope.each do |ea|
-          if id_to_instance.has_key? ea._ct_parent_id
-            output << "  #{ea._ct_parent_id} -> #{ea._ct_id}\n"
-          end
-          output << "  #{ea._ct_id} [label=\"#{ea.to_digraph_label}\"]\n"
-        end
-        output << "}\n"
-        output.string
-      end
-    end
   end
 end