closure_tree 2.0.0 → 3.0.0

data/README.md

@@ -105,12 +105,22 @@ Then:
 We can do all the node creation and add_child calls from the prior section with one method call:
 
   ```ruby
-  child = Tag.find_or_create_by_path("grandparent", "parent", "child")
+  child = Tag.find_or_create_by_path(["grandparent", "parent", "child"])
   ```
 
-You can ```find``` as well as ```find_or_create``` by "ancestry paths". 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```.
+You can ```find``` as well as ```find_or_create``` by "ancestry paths".
+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 the other columns will be null if nodes are created, other than auto-generated columns like ID and created_at timestamp. Only the specified column will receive the path element value.
+Note that any other AR fields can be set with the second, optional ```attributes``` argument.
+
+  ```ruby
+  child = Tag.find_or_create_by_path(%w{home chuck Photos"}, {:tag_type => "File"})
+  ```
+This will pass the attribute hash of ```{:name => "home", :tag_type => "File"}``` to
+```Tag.find_or_create_by_name``` if the root directory doesn't exist (and
+```{:name => "chuck", :tag_type => "File"}``` if the second-level tag doesn't exist, and so on).
 
 ### Available options
 <a id="options" />
@@ -129,35 +139,58 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
 
 ### Class methods
 
-* ``` Tag.root``` returns an arbitrary root node
-* ``` Tag.roots``` returns all root nodes
-* ``` Tag.leaves``` returns all leaf nodes
+* ```Tag.root``` returns an arbitrary root node
+* ```Tag.roots``` returns all root nodes
+* ```Tag.leaves``` returns all leaf nodes
 
 ### Instance methods
 
-* ``` tag.root``` returns the root for this node
-* ``` tag.root?``` returns true if this is a root node
-* ``` tag.child?``` returns true if this is a child node. It has a parent.
-* ``` tag.leaf?``` returns true if this is a leaf node. It has no children.
-* ``` tag.leaves``` returns an array of all the nodes in self_and_descendants that are leaves.
-* ``` tag.level``` returns the level, or "generation", for this node in the tree. A root node == 0.
-* ``` tag.parent``` returns the node's immediate parent. Root nodes will return nil.
-* ``` tag.children``` returns an array of immediate children (just those nodes whose parent is the current node).
-* ``` tag.ancestors``` returns an array of [ parent, grandparent, great grandparent, ... ]. Note that the size of this array will always equal ```tag.level```.
-* ``` tag.self_and_ancestors``` returns an array of self, parent, grandparent, great grandparent, etc.
-* ``` tag.siblings``` returns an array of brothers and sisters (all at that level), excluding self.
-* ``` tag.self_and_siblings``` returns an array of brothers and sisters (all at that level), including self.
-* ``` tag.descendants``` returns an array of all children, childrens' children, etc., excluding self.
-* ``` tag.self_and_descendants``` returns an array of all children, childrens' children, etc., including self.
-* ``` 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```.
-
-## Changelog
-
-### 2.0.0.beta1
+* ```tag.root``` returns the root for this node
+* ```tag.root?``` returns true if this is a root node
+* ```tag.child?``` returns true if this is a child node. It has a parent.
+* ```tag.leaf?``` returns true if this is a leaf node. It has no children.
+* ```tag.leaves``` returns an array of all the nodes in self_and_descendants that are leaves.
+* ```tag.level``` returns the level, or "generation", for this node in the tree. A root node == 0.
+* ```tag.parent``` returns the node's immediate parent. Root nodes will return nil.
+* ```tag.children``` returns an array of immediate children (just those nodes whose parent is the current node).
+* ```tag.ancestors``` returns an array of [ parent, grandparent, great grandparent, ... ]. Note that the size of this array will always equal ```tag.level```.
+* ```tag.self_and_ancestors``` returns an array of self, parent, grandparent, great grandparent, etc.
+* ```tag.siblings``` returns an array of brothers and sisters (all at that level), excluding self.
+* ```tag.self_and_siblings``` returns an array of brothers and sisters (all at that level), including self.
+* ```tag.descendants``` returns an array of all children, childrens' children, etc., excluding self.
+* ```tag.self_and_descendants``` returns an array of all children, childrens' children, etc., including self.
+* ```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```.
+
+## Polymorphic hierarchies
+
+Polymorphic models are supported:
+
+1. Create a db migration that adds a String ```type``` column to your model
+2. Subclass the model class. You only need to add acts_as_tree to your base class.
+
+  ```ruby
+  class Tag < ActiveRecord::Base
+    acts_as_tree
+  end
+  class WhenTag < Tag ; end
+  class WhereTag < Tag ; end
+  class WhatTag < Tag ; end
+  ```
+
+## Change log
+
+### 2.0.0
 
 * Had to increment the major version, as rebuild! will need to be called by prior consumers to support the new ```leaves``` class and instance methods.
 * Tag deletion is supported now along with ```:dependent => :destroy``` and ```:dependent => :delete_all```
 * Switched from default rails plugin directory structure to rspec
+* Support for running specs under different database engines: ```export DB ; for DB in sqlite3 mysql postgresql ; do rake ; done```
+
+### 3.0.0
+
+* Support for polymorphic trees
+* ```find_by_path``` and ```find_or_create_by_path``` signatures changed to support constructor attributes
+* tested against Rails 3.1.3
 
 ## Thanks to
 

data/lib/closure_tree/acts_as_tree.rb

@@ -10,6 +10,8 @@ module ClosureTree
         :name_column => 'name'
       }.merge(options)
 
+      raise IllegalArgumentException, "name_column can't be 'path'" if closure_tree_options[:name_column] == 'path'
+
       include ClosureTree::Columns
       extend ClosureTree::Columns
 
@@ -19,8 +21,8 @@ module ClosureTree
       self.hierarchy_class = Object.const_set hierarchy_class_name, Class.new(ActiveRecord::Base)
 
       self.hierarchy_class.class_eval <<-RUBY
-        belongs_to :ancestor, :class_name => "#{base_class.to_s}"
-        belongs_to :descendant, :class_name => "#{base_class.to_s}"
+        belongs_to :ancestor, :class_name => "#{ct_class.to_s}"
+        belongs_to :descendant, :class_name => "#{ct_class.to_s}"
       RUBY
 
       include ClosureTree::Model
@@ -30,23 +32,23 @@ module ClosureTree
       after_save :acts_as_tree_after_save
 
       belongs_to :parent,
-        :class_name => base_class.to_s,
+        :class_name => ct_class.to_s,
         :foreign_key => parent_column_name
 
       has_many :children,
-        :class_name => base_class.to_s,
+        :class_name => ct_class.to_s,
         :foreign_key => parent_column_name,
         :dependent => closure_tree_options[:dependent]
 
       has_and_belongs_to_many :self_and_ancestors,
-        :class_name => base_class.to_s,
+        :class_name => ct_class.to_s,
         :join_table => hierarchy_table_name,
         :foreign_key => "descendant_id",
         :association_foreign_key => "ancestor_id",
         :order => "generations asc"
 
       has_and_belongs_to_many :self_and_descendants,
-        :class_name => base_class.to_s,
+        :class_name => ct_class.to_s,
         :join_table => hierarchy_table_name,
         :foreign_key => "ancestor_id",
         :association_foreign_key => "descendant_id",
@@ -124,21 +126,39 @@ module ClosureTree
         without_self(self_and_siblings)
       end
 
-      # alias for appending to the children collect
+      # 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)
         children << child_node
         child_node
       end
 
       # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
-      # If the first argument is a symbol, it will be used as the column to search by
-      def find_by_path(*path)
-        foc_by_path("find", *path)
+      def find_by_path(path)
+        path = [path] unless path.is_a? Enumerable
+        node = self
+        while (!path.empty? && node)
+          node = node.children.send("find_by_#{name_column}", path.shift)
+        end
+        node
       end
 
       # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
-      def find_or_create_by_path(*path)
-        foc_by_path("find_or_create", *path)
+      def find_or_create_by_path(path, attributes = {})
+        path = [path] unless path.is_a? Enumerable
+        node = self
+        attrs = {}
+        attrs[:type] = self.type if ct_subclass? && ct_has_type?
+        path.each do |name|
+          attrs[name_sym] = name
+          child = node.children.where(attrs).first
+          unless child
+            child = self.class.new(attributes.merge attrs)
+            node.children << child
+          end
+          node = child
+        end
+        node
       end
 
       protected
@@ -195,16 +215,6 @@ module ClosureTree
         SQL
       end
 
-      def foc_by_path(method_prefix, *path)
-        path = path.flatten
-        return self if path.empty?
-        node = self
-        while (!path.empty? && node)
-          node = node.children.send("#{method_prefix}_by_#{name_column}", path.shift)
-        end
-        node
-      end
-
       def without_self(scope)
         scope.where(["#{quoted_table_name}.#{self.class.primary_key} != ?", self])
       end
@@ -230,17 +240,21 @@ module ClosureTree
       end
 
       # Find the node whose +ancestry_path+ is +path+
-      def find_by_path(*path)
-        path = path.flatten
-        r = roots.send("find_by_#{name_column}", path.shift)
-        r.nil? ? nil : r.find_by_path(*path)
+      def find_by_path(path)
+        root = roots.send("find_by_#{name_column}", path.shift)
+        root.try(:find_by_path, path)
       end
 
       # Find or create nodes such that the +ancestry_path+ is +path+
-      def find_or_create_by_path(*path)
-        path = path.flatten
-        root = roots.send("find_or_create_by_#{name_column}", path.shift)
-        root.find_or_create_by_path(*path)
+      def find_or_create_by_path(path, attributes = {})
+        name = path.shift
+        # 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.send("find_by_#{name_column}", name)
+        if root.nil?
+          root = create!(attributes.merge(name_sym => name))
+        end
+        root.find_or_create_by_path(path, attributes)
       end
     end
   end
@@ -289,6 +303,18 @@ module ClosureTree
       (self.is_a?(Class) ? self : self.class)
     end
 
+    def ct_subclass?
+      ct_class != ct_class.base_class
+    end
+
+    def ct_attribute_names
+      @ct_attr_names ||= ct_class.new.attributes.keys - ct_class.protected_attributes.to_a
+    end
+
+    def ct_has_type?
+      ct_attribute_names.include? 'type'
+    end
+
     def ct_table_name
       ct_class.table_name
     end

data/lib/closure_tree/version.rb

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

data/spec/db/schema.rb

@@ -37,4 +37,20 @@ ActiveRecord::Schema.define(:version => 0) do
 
   add_index :referral_hierarchies, [:ancestor_id, :descendant_id], :unique => true
   add_index :referral_hierarchies, [:descendant_id]
+
+  create_table "labels", :force => true do |t|
+    t.string   "name"
+    t.string   "type"
+    t.integer  "parent_id"
+  end
+
+  create_table "label_hierarchies", :id => false, :force => true do |t|
+    t.integer "ancestor_id",   :null => false
+    t.integer "descendant_id", :null => false
+    t.integer "generations",   :null => false
+  end
+
+  add_index :label_hierarchies, [:ancestor_id, :descendant_id], :unique => true
+  add_index :label_hierarchies, [:descendant_id]
+
 end

data/spec/label_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+def nuke_db
+  Label.delete_all
+  LabelHierarchy.delete_all
+end
+
+describe Label do
+  context "Base Label class" do
+    it "should find or create by path" do
+      # class method:
+      c = Label.find_or_create_by_path(%w{grandparent parent child})
+      c.ancestry_path.should == %w{grandparent parent child}
+      c.name.should == "child"
+      c.parent.name.should == "parent"
+    end
+  end
+  context "DateLabel" do
+
+    it "should find or create by path" do
+      date = DateLabel.find_or_create_by_path(%w{2011 November 23})
+      date.ancestry_path.should == %w{2011 November 23}
+      date.parent
+      date.self_and_ancestors.each { |ea| ea.class.should == DateLabel }
+      date.name.should == "23"
+      date.parent.name.should == "November"
+    end
+  end
+
+  context "DirectoryLabel" do
+    it "should find or create by path" do
+      dir = DirectoryLabel.find_or_create_by_path(%w{grandparent parent child})
+      dir.ancestry_path.should == %w{grandparent parent child}
+      dir.name.should == "child"
+      dir.parent.name.should == "parent"
+      dir.parent.parent.name.should == "grandparent"
+      dir.root.name.should == "grandparent"
+      dir.id.should_not == Label.find_or_create_by_path(%w{grandparent parent child})
+      dir.self_and_ancestors.each { |ea| ea.class.should == DirectoryLabel }
+    end
+  end
+
+  context "Mixed class tree" do
+    it "should support mixed type ancestors" do
+      [Label, DateLabel, DirectoryLabel, EventLabel].permutation do |classes|
+        nuke_db
+        classes.each{|c|c.all.should(be_empty, "class #{c} wasn't cleaned out") }
+        names = ('A'..'Z').to_a.first(classes.size)
+        instances = classes.collect { |clazz| clazz.new(:name => names.shift) }
+        a = instances.first
+        a.save!
+        a.name.should == "A"
+        instances[1..-1].each_with_index do |ea, idx|
+          instances[idx].children << ea
+        end
+        roots = classes.first.roots
+        i = instances.shift
+        roots.should =~ [i]
+        while (!instances.empty?) do
+          child = instances.shift
+          i.children.should =~ [child]
+          i = child
+        end
+      end
+    end
+  end
+end

data/spec/support/models.rb

@@ -1,12 +1,12 @@
 class Tag < ActiveRecord::Base
   acts_as_tree :dependent => :destroy
-  before_destroy :create_tag
+  before_destroy :add_destroyed_tag
 
   def to_s
     name
   end
 
-  def create_tag
+  def add_destroyed_tag
     # Proof for the tests that the destroy rather than the delete method was called:
     DestroyedTag.create(:name => name)
   end
@@ -24,3 +24,19 @@ class User < ActiveRecord::Base
     email
   end
 end
+
+class Label < ActiveRecord::Base
+  acts_as_tree
+  def to_s
+    "#{self.class}: #{name}"
+  end
+end
+
+class EventLabel < Label
+end
+
+class DateLabel < Label
+end
+
+class DirectoryLabel < Label
+end

data/spec/tag_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe "empty db" do
 
-  def nuke
+  def nuke_db
     Tag.delete_all
     TagHierarchy.delete_all
     DestroyedTag.delete_all
   end
 
   before :each do
-    nuke
+    nuke_db
   end
 
   context "empty db" do
@@ -63,7 +63,7 @@ describe "empty db" do
       Tag.all.should be_empty
       Tag.roots.should be_empty
       Tag.leaves.should be_empty
-      DestroyedTag.all.collect{|t|t.name}.should =~ %w{root mid leaf}
+      DestroyedTag.all.collect { |t| t.name }.should =~ %w{root mid leaf}
     end
   end
 
@@ -200,10 +200,10 @@ describe Tag do
     it "should cascade delete all children" do
       b2 = tags(:b2)
       entities = b2.self_and_descendants.to_a
-      names = b2.self_and_descendants.collect{|t|t.name}
+      names = b2.self_and_descendants.collect { |t| t.name }
       b2.destroy
-      entities.each{|e| Tag.find_by_id(e.id).should be_nil }
-      DestroyedTag.all.collect{|t|t.name}.should =~ names
+      entities.each { |e| Tag.find_by_id(e.id).should be_nil }
+      DestroyedTag.all.collect { |t| t.name }.should =~ names
     end
   end
 
@@ -257,9 +257,19 @@ describe Tag do
       tags(:parent).find_by_path(%w{child larvae}).should be_nil
     end
 
+    it "should return nil for missing nodes" do
+      Tag.find_by_path(%w{missing}).should be_nil
+      Tag.find_by_path(%w{grandparent missing}).should be_nil
+      Tag.find_by_path(%w{grandparent parent missing}).should be_nil
+      Tag.find_by_path(%w{grandparent parent missing child}).should be_nil
+    end
+
     it "should find or create by path" do
       # class method:
-      Tag.find_or_create_by_path(%w{grandparent parent child}).should == tags(:child)
+      grandparent = Tag.find_or_create_by_path(%w{grandparent})
+      grandparent.should == tags(:grandparent)
+      child = Tag.find_or_create_by_path(%w{grandparent parent child})
+      child.should == tags(:child)
       Tag.find_or_create_by_path(%w{events anniversary}).ancestry_path.should == %w{events anniversary}
       a = Tag.find_or_create_by_path(%w{a})
       a.ancestry_path.should == %w{a}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: closure_tree
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 7
   prerelease: 
   segments: 
-  - 2
+  - 3
   - 0
   - 0
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors: 
 - Matthew McEachen
@@ -15,10 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-24 00:00:00 Z
+date: 2011-11-27 00:00:00 -08:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -29,10 +31,9 @@ dependencies:
         - 0
         - 0
         version: 3.0.0
-  requirement: *id001
   type: :runtime
-  prerelease: false
   name: activerecord
+  version_requirements: *id001
 description: "    A mostly-API-compatible replacement for the acts_as_tree and awesome_nested_set gems,\n    but with much better mutation performance thanks to the Closure Tree storage algorithm\n"
 email: 
 - matthew-github@mceachen.org
@@ -53,10 +54,12 @@ files:
 - spec/db/database.yml
 - spec/db/schema.rb
 - spec/fixtures/tags.yml
+- spec/label_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/tag_spec.rb
 - spec/user_spec.rb
+has_rdoc: true
 homepage: http://matthew.mceachen.us/closure_tree
 licenses: []
 
@@ -86,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Hierarchies for ActiveRecord models using a Closure Tree storage algorithm
@@ -94,8 +97,8 @@ test_files:
 - spec/db/database.yml
 - spec/db/schema.rb
 - spec/fixtures/tags.yml
+- spec/label_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/tag_spec.rb
 - spec/user_spec.rb
-has_rdoc: