closure_tree 3.2.1 → 3.3.0

data/README.md

@@ -11,6 +11,7 @@ Closure Tree is a mostly-API-compatible replacement for the
 * Support for polymorphism [STI](#sti) within the hierarchy
 * ```find_or_create_by_path``` for [building out hierarchies quickly and conveniently](#find_or_create_by_path)
 * Support for [deterministic ordering](#deterministic-ordering) of children
+* Support for single-select depth-limited [nested hashes](#nested-hashes)
 * Excellent [test coverage](#testing) in a variety of environments
 
 See [Bill Karwin](http://karwin.blogspot.com/)'s excellent
@@ -25,7 +26,7 @@ Note that closure_tree only supports Rails 3.0 and later, and has test coverage
 
 2.  Run ```bundle install```
 
-3.  Add ```acts_as_tree``` to your hierarchical model(s) (see the <em>Available options</em> section below for details).
+3.  Add ```acts_as_tree``` to your hierarchical model(s). There are a number of [options](#available-options) you can pass in, too.
 
 4.  Add a migration to add a ```parent_id``` column to the model you want to act_as_tree.
     You may want to also [add a column for deterministic ordering of children](#sort_order), but that's optional.
@@ -84,31 +85,31 @@ grandparent = Tag.create(:name => 'Grandparent')
 Child nodes are created by appending to the children collection:
 
 ```ruby
-child = parent.children.create(:name => 'Child')
+parent = grandparent.children.create(:name => 'Parent')
 ```
 
 You can also append to the children collection:
 
 ```ruby
-child = Tag.create(:name => 'Child')
-parent.children << child
+child1 = Tag.create(:name => 'First Child')
+parent.children << child1
 ```
 
 Or call the "add_child" method:
 
 ```ruby
-parent = Tag.create(:name => 'Parent')
-grandparent.add_child parent
+child2 = Tag.create(:name => 'Second Child')
+parent.add_child child2
 ```
 
 Then:
 
 ```ruby
-puts grandparent.self_and_descendants.collect{ |t| t.name }.join(" > ")
-=> "grandparent > parent > child"
+grandparent.self_and_descendants.collect(&:name)
+=> ["Grandparent", "Parent", "First Child", "Second Child"]
 
-child.ancestry_path
-=> ["grandparent", "parent", "child"]
+child1.ancestry_path
+=> ["Grandparent", "Parent", "First Child"]
 ```
 
 ### find_or_create_by_path
@@ -146,13 +147,42 @@ h.ancestry_path
 => ["a", "b", "c", "d", "e", "f", "g", "h"]
 ```
 
+### Nested hashes
+
+```hash_tree``` provides a method for rendering a subtree as an
+ordered nested hash:
+
+```ruby
+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
+=> {a => {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}, b2 => {}}}
+
+Tag.hash_tree(:limit_depth => 2)
+=> {a => {b => {}, b2 => {}}}
+
+b.hash_tree
+=> {b => {c1 => {d1 => {}}, c2 => {d2 => {}}}}
+
+b.hash_tree(:limit_depth => 2)
+=> {b => {c1 => {}, c2 => {}}}
+```
+
+HT: [ancestry](https://github.com/stefankroes/ancestry#arrangement) and [elhoyos](https://github.com/mceachen/closure_tree/issues/11)
+
 ### <a id="options"></a>Available options
 
 When you include ```acts_as_tree``` in your model, you can provide a hash to override the following defaults:
 
 * ```:parent_column_name``` to override the column name of the parent foreign key in the model's table. This defaults to "parent_id".
 * ```:hierarchy_table_name``` to override the hierarchy table name. This defaults to the singular name of the model + "_hierarchies".
-* ```:dependent``` determines what happens when a node is destroyed. Defaults to ```nil```.
+* ```:dependent``` determines what happens when a node is destroyed. Defaults to ```nullify```.
     * ```:nullify``` will simply set the parent column to null. Each child node will be considered a "root" node. This is the default.
     * ```:delete_all``` will delete all descendant nodes (which circumvents the destroy hooks)
     * ```:destroy``` will destroy all descendant nodes (which runs the destroy hooks on each child node)
@@ -166,6 +196,7 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
 * ```Tag.root``` returns an arbitrary root node
 * ```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.
 
 ### Instance methods
 
@@ -186,6 +217,7 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
 * ```tag.descendants``` returns a scope of all children, childrens' children, etc., excluding self ordered by depth.
 * ```tag.descendant_ids``` returns an array of the IDs of the descendants.
 * ```tag.self_and_descendants``` returns a scope of all children, childrens' children, etc., including self, ordered by depth.
+* ```tag.hash_tree``` returns an [ordered, nested hash](#nested-hashes) that can be depth-limited.
 * ```tag.destroy``` will destroy a node and do <em>something</em> to its children, which is determined by the ```:dependent``` option passed to ```acts_as_tree```.
 
 ## <a id="sti"></a>Polymorphic hierarchies with STI
@@ -285,6 +317,10 @@ Closure tree is [tested under every combination](https://secure.travis-ci.org/mc
 
 ## Change log
 
+### 3.3.0
+
+* Added [```hash_tree```](#nested-hashes).
+
 ### 3.2.1
 
 * Added ```ancestor_ids```, ```descendant_ids```, and ```sibling_ids```

data/lib/closure_tree/acts_as_tree.rb

@@ -56,18 +56,18 @@ module ClosureTree
       has_many :ancestor_hierarchies,
         :class_name => hierarchy_class_name,
         :foreign_key => "descendant_id",
-        :order => "generations asc",
+        :order => "#{quoted_hierarchy_table_name}.generations asc",
         :dependent => :destroy
 
       has_many :self_and_ancestors,
         :through => :ancestor_hierarchies,
         :source => :ancestor,
-        :order => "generations asc"
+        :order => "#{quoted_hierarchy_table_name}.generations asc"
 
       has_many :descendant_hierarchies,
         :class_name => hierarchy_class_name,
         :foreign_key => "ancestor_id",
-        :order => "generations asc",
+        :order => "#{quoted_hierarchy_table_name}.generations asc",
         :dependent => :destroy
       # TODO: FIXME: this collection currently ignores sort_order
       # (because the quoted_table_named would need to be joined in to get to the order column)
@@ -75,18 +75,22 @@ module ClosureTree
       has_many :self_and_descendants,
         :through => :descendant_hierarchies,
         :source => :descendant,
-        :order => append_order("generations asc")
+        :order => append_order("#{quoted_hierarchy_table_name}.generations asc")
 
       def self.roots
         where(parent_column_name => nil)
       end
 
+      def self.hash_tree(options = {})
+        roots.inject(ActiveSupport::OrderedHash.new) { |h, ea| h.merge(ea.hash_tree(options)) }
+      end
+
       def self.leaves
         s = where("#{quoted_table_name}.#{primary_key} IN
         (SELECT ancestor_id
          FROM #{quoted_hierarchy_table_name}
          GROUP BY 1
-         HAVING MAX(generations) = 0)")
+         HAVING MAX(#{quoted_hierarchy_table_name}.generations) = 0)")
         order_option ? s.order(order_option) : s
       end
     end
@@ -203,6 +207,22 @@ module ClosureTree
       node
     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)
+      end
+      tree
+    end
+
     protected
 
     def ct_validate

data/lib/closure_tree/version.rb

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

data/spec/tag_spec.rb

@@ -76,7 +76,7 @@ shared_examples_for Tag do
       end
 
       it "should create all tags" do
-        Tag.all.should == [@root, @mid, @leaf]
+        Tag.all.should =~ [@root, @mid, @leaf]
       end
 
       it "should return a root and leaf without middle tag" do
@@ -118,6 +118,28 @@ shared_examples_for Tag do
         TagHierarchy.find_all_by_descendant_id(@root.id).should == root_hiers
       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
   end
 
   describe Tag do

data/spec/user_spec.rb

@@ -86,4 +86,22 @@ describe "empty db" do
     c2 = u.parent.contracts.create!
     u.root.indirect_contracts.to_a.should =~ [c1, c2]
   end
+
+  it "performs as the readme says it does" do
+    grandparent = Tag.create(:name => 'Grandparent')
+    parent = grandparent.children.create(:name => 'Parent')
+    child1 = Tag.create(:name => 'First Child')
+    parent.children << child1
+    child2 = Tag.create(:name => 'Second Child')
+    parent.add_child child2
+    grandparent.self_and_descendants.collect(&:name).should ==
+      ["Grandparent", "Parent", "First Child", "Second Child"]
+    child1.ancestry_path.should ==
+      ["Grandparent", "Parent", "First Child"]
+    d = Tag.find_or_create_by_path %w(a b c d)
+    h = Tag.find_or_create_by_path %w(e f g h)
+    e = h.root
+    d.add_child(e) # "d.children << e" would work too, of course
+    h.ancestry_path.should == %w(a b c d e f g h)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
+date: 2012-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -193,7 +193,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1184203510025686599
+      hash: 1888023415669580942
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -202,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1184203510025686599
+      hash: 1888023415669580942
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.21