closure_tree 3.6.8 → 3.6.9

data/README.md

@@ -203,6 +203,11 @@ b.hash_tree(:limit_depth => 2)
 => {b => {c1 => {}, c2 => {}}}
 ```
 
+**If your tree is large (or might become so), use :limit_depth.**
+
+Without this option, ```hash_tree``` will load the entire contents of that table into RAM. Your
+server may not be happy trying to do this.
+
 HT: [ancestry](https://github.com/stefankroes/ancestry#arrangement) and [elhoyos](https://github.com/mceachen/closure_tree/issues/11)
 
 ### <a id="options"></a>Available options
@@ -367,10 +372,11 @@ Closure tree is [tested under every combination](http://travis-ci.org/#!/mceache
 
 ## Change log
 
-### 3.6.8
+### 3.6.9
 
 * [Don Morrison](https://github.com/elskwid) massaged the [#hash_tree](#nested-hashes) query to
-be more efficient.
+be more efficient, and found a bug in ```hash_tree```'s query that resulted in duplicate rows,
+wasting time on the ruby side.
 
 ### 3.6.7
 

data/lib/closure_tree/acts_as_tree.rb

@@ -56,8 +56,8 @@ module ClosureTree
 
       has_many :children, with_order_option(
         :class_name => ct_class.to_s,
-          :foreign_key => parent_column_name,
-          :dependent => closure_tree_options[:dependent]
+        :foreign_key => parent_column_name,
+        :dependent => closure_tree_options[:dependent]
       )
 
       has_many :ancestor_hierarchies,
@@ -88,39 +88,10 @@ module ClosureTree
         where(parent_column_name => nil)
       end
 
-      # Note that options[:limit_depth] defaults to 10. This might be crazy-big, depending on your tree shape.
+      # There is no default depth limit. This might be crazy-big, depending
+      # on your tree shape. Hash huge trees at your own peril!
       def self.hash_tree(options = {})
-        tree = ActiveSupport::OrderedHash.new
-        id_to_hash = {}
-        limit_depth = (options[:limit_depth] || 10).to_i
-
-        # Simple join with hierarchy for ancestor, descendant, and generation
-        scope = joins(:ancestor_hierarchies)
-
-        # Deepest generation, within limit, for each descendant
-        scope = scope.joins(<<-SQL)
-          INNER JOIN (
-            SELECT
-              #{quoted_hierarchy_table_name}.descendant_id,
-              MAX(#{quoted_hierarchy_table_name}.generations) AS depth
-            FROM #{quoted_hierarchy_table_name}
-            GROUP BY #{quoted_hierarchy_table_name}.descendant_id
-            HAVING MAX(#{quoted_hierarchy_table_name}.generations) <= #{limit_depth - 1}
-          ) AS generation_depth
-          ON #{quoted_hierarchy_table_name}.descendant_id = generation_depth.descendant_id
-        SQL
-
-        scope = scope.order(append_order("generation_depth.depth"))
-
-        scope.each do |ea|
-          h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
-          if ea.root?
-            tree[ea] = h
-          else
-            id_to_hash[ea.ct_parent_id][ea] = h
-          end
-        end
-        tree
+        build_hash_tree(hash_tree_scope(options[:limit_depth]))
       end
 
       def find_all_by_generation(generation_level)
@@ -274,20 +245,17 @@ module ClosureTree
       order_option ? s.order(order_option) : s
     end
 
-    def hash_tree(options = {})
-      tree = ActiveSupport::OrderedHash.new
-      tree[self] = ActiveSupport::OrderedHash.new
-      id_to_hash = {self.id => tree[self]}
-      scope = descendants
-      if options[:limit_depth]
-        limit_depth = options[:limit_depth]
-        return {} if limit_depth <= 0
-        scope = scope.where("generations <= #{limit_depth - 1}")
-      end
-      scope.each do |ea|
-        id_to_hash[ea.ct_parent_id][ea] = (id_to_hash[ea.id] = ActiveSupport::OrderedHash.new)
+    def hash_tree_scope(limit_depth = nil)
+      scope = self_and_descendants
+      if limit_depth
+        scope.where("#{quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}")
+      else
+        scope
       end
-      tree
+    end
+
+    def hash_tree(options = {})
+      self.class.build_hash_tree(hash_tree_scope(options[:limit_depth]))
     end
 
     def ct_parent_id
@@ -401,6 +369,38 @@ module ClosureTree
         end
         root.find_or_create_by_path(path, attributes)
       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 (!!)
+        generation_depth = <<-SQL
+          INNER JOIN (
+            SELECT descendant_id, MAX(generations) as depth
+            FROM #{quoted_hierarchy_table_name}
+            GROUP BY descendant_id
+            #{"HAVING MAX(generations) <= #{limit_depth - 1}" if limit_depth}
+          ) AS generation_depth
+            ON #{quoted_table_name}.#{primary_key} = generation_depth.descendant_id
+        SQL
+        scoped.joins(generation_depth).order(append_order("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
 
@@ -563,9 +563,9 @@ module ClosureTree
         # issue 21: we have to use the base class, so STI doesn't get in the way of only updating the child class instances:
         ct_base_class.update_all(
           ["#{col} = #{col} #{add_after ? '+' : '-'} 1", "updated_at = now()"],
-            ["#{quoted_parent_column_name} = ? AND #{col} #{add_after ? '>=' : '<='} ?",
-              ct_parent_id,
-              sibling_node.order_value])
+          ["#{quoted_parent_column_name} = ? AND #{col} #{add_after ? '>=' : '<='} ?",
+            ct_parent_id,
+            sibling_node.order_value])
       else
         last_value = sibling_node.order_value.to_i
         (add_after ? siblings_after : siblings_before.reverse).each do |ea|

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = "3.6.8" unless defined?(::ClosureTree::VERSION)
+  VERSION = "3.6.9" unless defined?(::ClosureTree::VERSION)
 end

data/spec/hash_tree_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Tag do
+
+  before :each do
+    @b = Tag.find_or_create_by_path %w(a b)
+    @a = @b.parent
+    @b2 = Tag.find_or_create_by_path %w(a b2)
+    @d1 = @b.find_or_create_by_path %w(c1 d1)
+    @c1 = @d1.parent
+    @d2 = @b.find_or_create_by_path %w(c2 d2)
+    @c2 = @d2.parent
+    @full_tree = {@a => {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}, @b2 => {}}}
+  end
+
+  context "#hash_tree" do
+    it "returns {} for depth 0" do
+      Tag.hash_tree(:limit_depth => 0).should == {}
+    end
+    it "limit_depth 1" do
+      Tag.hash_tree(:limit_depth => 1).should == {@a => {}}
+    end
+    it "limit_depth 2" do
+      Tag.hash_tree(:limit_depth => 2).should == {@a => {@b => {}, @b2 => {}}}
+    end
+    it "limit_depth 3" do
+      Tag.hash_tree(:limit_depth => 3).should == {@a => {@b => {@c1 => {}, @c2 => {}}, @b2 => {}}}
+    end
+    it "limit_depth 4" do
+      Tag.hash_tree(:limit_depth => 4).should == @full_tree
+    end
+    it "no limit holdum" do
+      Tag.hash_tree.should == @full_tree
+    end
+  end
+
+  def assert_no_dupes(scope)
+    # the named scope is complicated enough that an incorrect join could result in unnecessarily
+    # duplicated rows:
+    a = scope.collect { |ea| ea.id }
+    a.should == a.uniq
+  end
+
+  context "#hash_tree_scope" do
+    it "no dupes for any depth" do
+      (0..5).each do |ea|
+        assert_no_dupes(Tag.hash_tree_scope(ea))
+      end
+    end
+    it "no limit holdum" do
+      assert_no_dupes(Tag.hash_tree_scope)
+    end
+  end
+
+  context ".hash_tree_scope" do
+    it "no dupes for any depth" do
+      (0..5).each do |ea|
+        assert_no_dupes(@a.hash_tree_scope(ea))
+      end
+    end
+    it "no limit holdum" do
+      assert_no_dupes(@a.hash_tree_scope)
+    end
+  end
+
+  context ".hash_tree" do
+    before :each do
+    end
+    it "returns {} for depth 0" do
+      @b.hash_tree(:limit_depth => 0).should == {}
+    end
+    it "limit_depth 1" do
+      @b.hash_tree(:limit_depth => 1).should == {@b => {}}
+    end
+    it "limit_depth 2" do
+      @b.hash_tree(:limit_depth => 2).should == {@b => {@c1 => {}, @c2 => {}}}
+    end
+    it "limit_depth 3" do
+      @b.hash_tree(:limit_depth => 3).should == {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}}
+    end
+    it "no limit holdum from subsubroot" do
+      @c1.hash_tree.should == {@c1 => {@d1 => {}}}
+    end
+    it "no limit holdum from subroot" do
+      @b.hash_tree.should == {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}}
+    end
+    it "no limit holdum from root" do
+      @a.hash_tree.should == @full_tree
+    end
+  end
+end

data/spec/tag_spec.rb

@@ -124,28 +124,6 @@ shared_examples_for Tag do
       end
     end
 
-    it "builds hash_trees properly" do
-      b = Tag.find_or_create_by_path %w(a b)
-      a = b.parent
-      b2 = Tag.find_or_create_by_path %w(a b2)
-      d1 = b.find_or_create_by_path %w(c1 d1)
-      c1 = d1.parent
-      d2 = b.find_or_create_by_path %w(c2 d2)
-      c2 = d2.parent
-      Tag.hash_tree(:limit_depth => 0).should == {}
-      Tag.hash_tree(:limit_depth => 1).should == {a => {}}
-      Tag.hash_tree(:limit_depth => 2).should == {a => {b => {}, b2 => {}}}
-      tree = {a => {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}, b2 => {}}}
-      Tag.hash_tree(:limit_depth => 4).should == tree
-      Tag.hash_tree.should == tree
-      b.hash_tree(:limit_depth => 0).should == {}
-      b.hash_tree(:limit_depth => 1).should == {b => {}}
-      b.hash_tree(:limit_depth => 2).should == {b => {c1 => {}, c2 => {}}}
-      b_tree = {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}}
-      b.hash_tree(:limit_depth => 3).should == b_tree
-      b.hash_tree.should == b_tree
-    end
-
     it "performs as the readme says it does" do
       grandparent = Tag.create(:name => 'Grandparent')
       parent = grandparent.children.create(:name => 'Parent')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 3.6.8
+  version: 3.6.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-29 00:00:00.000000000 Z
+date: 2012-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -189,6 +189,7 @@ files:
 - spec/db/schema.rb
 - spec/fixtures/labels.yml
 - spec/fixtures/tags.yml
+- spec/hash_tree_spec.rb
 - spec/label_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
@@ -208,7 +209,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1831255790364540871
+      hash: -2239773870557793017
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -217,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1831255790364540871
+      hash: -2239773870557793017
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -230,6 +231,7 @@ test_files:
 - spec/db/schema.rb
 - spec/fixtures/labels.yml
 - spec/fixtures/tags.yml
+- spec/hash_tree_spec.rb
 - spec/label_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb