closure_tree 3.0.2 → 3.0.3

data/README.md

@@ -1,5 +1,7 @@
 # Closure Tree
 
+[![Build Status](https://secure.travis-ci.org/mceachen/closure_tree.png?branch=master)](http://travis-ci.org/mceachen/closure_tree)
+
 Closure Tree is a mostly-API-compatible replacement for the
 acts_as_tree and awesome_nested_set gems, but with much better
 mutation performance thanks to the Closure Tree storage algorithm,
@@ -9,9 +11,9 @@ See [Bill Karwin](http://karwin.blogspot.com/)'s excellent
 [Models for hierarchical data presentation](http://www.slideshare.net/billkarwin/models-for-hierarchical-data)
 for a description of different tree storage algorithms.
 
-## Setup
+## Installation
 
-Note that closure_tree supports Rails 3. Rails 2, not so much.
+Note that closure_tree only supports Rails 3.0 and later, and has test coverage for MySQL, PostgreSQL, and SQLite.
 
 1.  Add this to your Gemfile: ```gem 'closure_tree'```
 
@@ -21,8 +23,6 @@ Note that closure_tree supports Rails 3. Rails 2, not so much.
 
 4.  Add a migration to add a ```parent_id``` column to the model you want to act_as_tree.
 
-    Note that if the column is null, the tag will be considered a root node.
-
     ```ruby
     class AddParentIdToTag < ActiveRecord::Migration
       def change
@@ -31,9 +31,12 @@ Note that closure_tree supports Rails 3. Rails 2, not so much.
     end
     ```
 
+    Note that if the column is null, the tag will be considered a root node.
+
 5.  Add a database migration to store the hierarchy for your model. By
-    convention the table name will be the model's table name, followed by
-    "_hierarchy". Note that by calling ```acts_as_tree```, a "virtual model" (in this case, ```TagsHierarchy```) will be added automatically, so you don't need to create it.
+    default the table name will be the model's table name, followed by
+    "_hierarchies". Note that by calling ```acts_as_tree```, a "virtual model" (in this case, ```TagsHierarchy```)
+    will be added automatically, so you don't need to create it.
 
     ```ruby
     class CreateTagHierarchies < ActiveRecord::Migration
@@ -44,10 +47,10 @@ Note that closure_tree supports Rails 3. Rails 2, not so much.
           t.integer  :generations, :null => false   # Number of generations between the ancestor and the descendant. Parent/child = 1, for example.
         end
 
-        # For "all progeny of..." selects:
+        # For "all progeny of…" selects:
         add_index :tag_hierarchies, [:ancestor_id, :descendant_id], :unique => true
 
-        # For "all ancestors of..." selects
+        # For "all ancestors of…" selects
         add_index :tag_hierarchies, [:descendant_id]
       end
     end
@@ -55,9 +58,9 @@ Note that closure_tree supports Rails 3. Rails 2, not so much.
 
 6.  Run ```rake db:migrate```
 
-7.  If you're migrating away from another system where your model already has a
+7.  If you're migrating from another system where your model already has a
     ```parent_id``` column, run ```Tag.rebuild!``` and the
-    ..._hierarchy table will be truncated and rebuilt.
+    …_hierarchy table will be truncated and rebuilt.
 
     If you're starting from scratch you don't need to call ```rebuild!```.
 
@@ -154,7 +157,7 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
 * ```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.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.
@@ -201,6 +204,12 @@ class WhatTag < Tag ; end
 
 * Fix for ancestry-loop detection (performed by a validation, not through raising an exception in before_save)
 
+### 3.0.3
+
+* Added support for ActiveRecord's whitelist_attributes
+  (Make sure you read [the Rails Security Guide](http://guides.rubyonrails.org/security.html), and
+  enable ```config.active_record.whitelist_attributes``` in your ```config/application.rb``` ASAP!)
+
 ## Thanks to
 
 * https://github.com/collectiveidea/awesome_nested_set

data/lib/closure_tree/acts_as_tree.rb

@@ -23,6 +23,7 @@ module ClosureTree
       self.hierarchy_class.class_eval <<-RUBY
         belongs_to :ancestor, :class_name => "#{ct_class.to_s}"
         belongs_to :descendant, :class_name => "#{ct_class.to_s}"
+        attr_accessible :ancestor, :descendant, :generations
       RUBY
 
       include ClosureTree::Model
@@ -137,7 +138,7 @@ module ClosureTree
     def find_by_path(path)
       path = [path] unless path.is_a? Enumerable
       node = self
-      while (!path.empty? && node)
+      while !path.empty? && node
         node = node.children.send("find_by_#{name_column}", path.shift)
       end
       node
@@ -153,7 +154,7 @@ module ClosureTree
         attrs[name_sym] = name
         child = node.children.where(attrs).first
         unless child
-          child = self.class.new(attributes.merge attrs)
+          child = self.class.new(attributes.merge(attrs))
           node.children << child
         end
         node = child
@@ -173,7 +174,7 @@ module ClosureTree
 
     def acts_as_tree_before_save
       @was_new_record = new_record?
-      nil # AR will cancel the save if this is falsy
+      true # don't cancel the save
     end
 
     def acts_as_tree_after_save

data/lib/closure_tree/version.rb

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

data/spec/db/database.yml

@@ -7,12 +7,10 @@ sqlite3mem:
 postgresql:
   adapter: postgresql
   username: postgres
-  password: postgres
-  database: closure_tree_plugin_test
+  database: closure_tree_test
   min_messages: ERROR
 mysql:
   adapter: mysql2
   host: localhost
   username: root
-  password:
-  database: closure_tree_plugin_test
+  database: closure_tree_test

data/spec/spec_helper.rb

@@ -10,7 +10,7 @@ require 'logger'
 require 'active_support'
 require 'active_model'
 require 'active_record'
-require 'action_controller'
+require 'action_controller' # rspec-rails needs this :(
 
 require 'closure_tree'
 
@@ -24,8 +24,8 @@ ActiveRecord::Migration.verbose = false
 load(File.join(plugin_test_dir, "db", "schema.rb"))
 
 require 'support/models'
+require 'rspec/rails' # TODO: clean this up-- I don't want to pull the elephant through the mouse hole just for fixture support
 
-require 'rspec/rails'
 RSpec.configure do |config|
   config.fixture_path = "#{plugin_test_dir}/fixtures"
   # true runs the tests 1 second faster, but then you can't

data/spec/support/models.rb

@@ -1,6 +1,7 @@
 class Tag < ActiveRecord::Base
   acts_as_tree :dependent => :destroy
   before_destroy :add_destroyed_tag
+  attr_accessible :name
 
   def to_s
     name
@@ -13,12 +14,14 @@ class Tag < ActiveRecord::Base
 end
 
 class DestroyedTag < ActiveRecord::Base
+  attr_accessible :name
 end
 
 class User < ActiveRecord::Base
   acts_as_tree :parent_column_name => "referrer_id",
     :name_column => 'email',
     :hierarchy_table_name => 'referral_hierarchies'
+  attr_accessible :email, :referrer
 
   def to_s
     email
@@ -27,6 +30,8 @@ end
 
 class Label < ActiveRecord::Base
   acts_as_tree
+  attr_accessible :name
+
   def to_s
     "#{self.class}: #{name}"
   end
@@ -39,4 +44,4 @@ class DateLabel < Label
 end
 
 class DirectoryLabel < Label
-end
+end

data/spec/tag_spec.rb

@@ -1,293 +1,307 @@
 require 'spec_helper'
 
-describe "empty db" do
+shared_examples_for Tag do
+  describe "empty db" do
 
-  def nuke_db
-    Tag.delete_all
-    TagHierarchy.delete_all
-    DestroyedTag.delete_all
-  end
-
-  before :each do
-    nuke_db
-  end
-
-  context "empty db" do
-    it "should return no entities" do
-      Tag.roots.should be_empty
-      Tag.leaves.should be_empty
+    def nuke_db
+      Tag.delete_all
+      TagHierarchy.delete_all
+      DestroyedTag.delete_all
     end
-  end
-
-  context "1 tag db" do
-    it "should return the only entity as a root and leaf" do
-      a = Tag.create!(:name => "a")
-      Tag.roots.should == [a]
-      Tag.leaves.should == [a]
-    end
-  end
-
-  context "2 tag db" do
-    it "should return a simple root and leaf" do
-      root = Tag.create!(:name => "root")
-      leaf = root.add_child(Tag.create!(:name => "leaf"))
-      Tag.roots.should == [root]
-      Tag.leaves.should == [leaf]
-    end
-  end
 
-  context "3 tag collection.create db" do
     before :each do
-      @root = Tag.create! :name => "root"
-      @mid = @root.children.create! :name => "mid"
-      @leaf = @mid.children.create! :name => "leaf"
-    end
-
-    it "should create all tags" do
-      Tag.all.should =~ [@root, @mid, @leaf]
-    end
-
-    it "should return a root and leaf without middle tag" do
-      Tag.roots.should == [@root]
-      Tag.leaves.should == [@leaf]
-    end
-
-    it "should delete leaves" do
-      Tag.leaves.destroy_all
-      Tag.roots.should == [@root] # untouched
-      Tag.leaves.should == [@mid]
-    end
-
-    it "should delete everything if you delete the roots" do
-      Tag.roots.destroy_all
-      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}
+      nuke_db
+    end
+
+    context "empty db" do
+      it "should return no entities" do
+        Tag.roots.should be_empty
+        Tag.leaves.should be_empty
+      end
+    end
+
+    context "1 tag db" do
+      it "should return the only entity as a root and leaf" do
+        a = Tag.create!(:name => "a")
+        Tag.roots.should == [a]
+        Tag.leaves.should == [a]
+      end
+    end
+
+    context "2 tag db" do
+      it "should return a simple root and leaf" do
+        root = Tag.create!(:name => "root")
+        leaf = root.add_child(Tag.create!(:name => "leaf"))
+        Tag.roots.should == [root]
+        Tag.leaves.should == [leaf]
+      end
+    end
+
+    context "3 tag collection.create db" do
+      before :each do
+        @root = Tag.create! :name => "root"
+        @mid = @root.children.create! :name => "mid"
+        @leaf = @mid.children.create! :name => "leaf"
+      end
+
+      it "should create all tags" do
+        Tag.all.should =~ [@root, @mid, @leaf]
+      end
+
+      it "should return a root and leaf without middle tag" do
+        Tag.roots.should == [@root]
+        Tag.leaves.should == [@leaf]
+      end
+
+      it "should delete leaves" do
+        Tag.leaves.destroy_all
+        Tag.roots.should == [@root] # untouched
+        Tag.leaves.should == [@mid]
+      end
+
+      it "should delete everything if you delete the roots" do
+        Tag.roots.destroy_all
+        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}
+      end
+    end
+
+    context "3 tag explicit_create db" do
+      before :each do
+        @root = Tag.create!(:name => "root")
+        @mid = @root.add_child(Tag.create!(:name => "mid"))
+        @leaf = @mid.add_child(Tag.create!(:name => "leaf"))
+      end
+
+      it "should create all tags" do
+        Tag.all.should =~ [@root, @mid, @leaf]
+      end
+
+      it "should return a root and leaf without middle tag" do
+        Tag.roots.should == [@root]
+        Tag.leaves.should == [@leaf]
+      end
+
+      it "should prevent parental loops from torso" do
+        @mid.children << @root
+        @root.valid?.should be_false
+        @mid.reload.children.should == [@leaf]
+      end
+
+      it "should prevent parental loops from toes" do
+        @leaf.children << @root
+        @root.valid?.should be_false
+        @leaf.reload.children.should be_empty
+      end
+
+      it "should support reparenting" do
+        @root.children << @leaf
+        Tag.leaves.should =~ [@leaf, @mid]
+      end
     end
   end
 
-  context "3 tag explicit_create db" do
-    before :each do
-      @root = Tag.create!(:name => "root")
-      @mid = @root.add_child(Tag.create!(:name => "mid"))
-      @leaf = @mid.add_child(Tag.create!(:name => "leaf"))
-    end
-
-    it "should create all tags" do
-      Tag.all.should =~ [@root, @mid, @leaf]
-    end
+  describe Tag do
 
-    it "should return a root and leaf without middle tag" do
-      Tag.roots.should == [@root]
-      Tag.leaves.should == [@leaf]
-    end
+    fixtures :tags
 
-    it "should prevent parental loops from torso" do
-      @mid.children << @root
-      @root.valid?.should be_false
-      @mid.reload.children.should == [@leaf]
+    before :each do
+      Tag.rebuild!
+    end
+
+    context "class injection" do
+      it "should build hierarchy classname correctly" do
+        Tag.hierarchy_class.to_s.should == "TagHierarchy"
+        Tag.hierarchy_class_name.should == "TagHierarchy"
+      end
+
+      it "should have a correct parent column name" do
+        Tag.parent_column_name.should == "parent_id"
+      end
+    end
+
+    context "roots" do
+      it "should find global roots" do
+        roots = Tag.roots.to_a
+        roots.should be_member(tags(:people))
+        roots.should be_member(tags(:events))
+        roots.should_not be_member(tags(:child))
+        tags(:people).root?.should be_true
+        tags(:child).root?.should be_false
+      end
+
+      it "should find an instance root" do
+        tags(:grandparent).root.should == tags(:grandparent)
+        tags(:parent).root.should == tags(:grandparent)
+        tags(:child).root.should == tags(:grandparent)
+      end
+    end
+
+    context "leaves" do
+      it "should assemble global leaves" do
+        Tag.leaves.size.should > 0
+        Tag.leaves.each { |t| t.children.should be_empty, "#{t.name} was returned by leaves but has children: #{t.children}" }
+        Tag.leaves.each { |t| t.should be_leaf, "{t.name} was returned by leaves but was not a leaf" }
+      end
+
+      it "should assemble instance leaves" do
+        tags(:grandparent).leaves.should == [tags(:child)]
+        tags(:parent).leaves.should == [tags(:child)]
+        tags(:child).leaves.should == [tags(:child)]
+      end
+    end
+
+    context "adding children" do
+      it "should work explicitly" do
+        sb = Tag.create!(:name => "Santa Barbara")
+        sb.leaf?.should_not be_nil
+        tags(:california).add_child sb
+        sb.leaf?.should_not be_nil
+        validate_city_tag sb
+      end
+
+      it "should work implicitly through the collection" do
+        eg = Tag.create!(:name => "El Granada")
+        eg.leaf?.should_not be_nil
+        tags(:california).children << eg
+        eg.leaf?.should_not be_nil
+        validate_city_tag eg
+      end
+
+      it "should fail to create ancestor loops" do
+        child = tags(:child)
+        parent = child.parent
+        child.add_child(parent) # this should fail
+        parent.valid?.should be_false
+        child.reload.children.should be_empty
+        parent.reload.children.should =~ [child]
+      end
+
+      it "should move non-leaves" do
+        # This is what the fixture should encode:
+        tags(:d2).ancestry_path.should == %w{a1 b2 c2 d2}
+        tags(:b1).add_child(tags(:c2))
+        tags(:b2).leaf?.should_not be_nil
+        tags(:b1).children.include?(tags(:c2)).should_not be_nil
+        tags(:d2).reload.ancestry_path.should == %w{a1 b1 c2 d2}
+      end
+
+      it "should move leaves" do
+        l = Tag.find_or_create_by_path(%w{leaftest branch1 leaf})
+        b2 = Tag.find_or_create_by_path(%w{leaftest branch2})
+        b2.children << l
+        l.ancestry_path.should == %w{leaftest branch2 leaf}
+      end
+
+      it "should move roots" do
+        l1 = Tag.find_or_create_by_path(%w{roottest1 branch1 leaf1})
+        l2 = Tag.find_or_create_by_path(%w{roottest2 branch2 leaf2})
+        l1.children << l2.root
+        l1.ancestry_path.should == %w{roottest1 branch1 leaf1}
+        l2.ancestry_path.should == %w{roottest1 branch1 leaf1 roottest2 branch2 leaf2}
+      end
+
+      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 }
+        b2.destroy
+        entities.each { |e| Tag.find_by_id(e.id).should be_nil }
+        DestroyedTag.all.collect { |t| t.name }.should =~ names
+      end
+    end
+
+    context "injected attributes" do
+      it "should compute level correctly" do
+        tags(:grandparent).level.should == 0
+        tags(:parent).level.should == 1
+        tags(:child).level.should == 2
+      end
+
+      it "should determine parent correctly" do
+        tags(:grandparent).parent.should == nil
+        tags(:parent).parent.should == tags(:grandparent)
+        tags(:child).parent.should == tags(:parent)
+      end
+
+      it "should have a sane children collection" do
+        tags(:grandparent).children.include? tags(:parent).should_not be_nil
+        tags(:parent).children.include? tags(:child).should_not be_nil
+        tags(:child).children.empty?.should_not be_nil
+      end
+
+      it "should assemble ancestors correctly" do
+        tags(:child).ancestors.should == [tags(:parent), tags(:grandparent)]
+        tags(:child).self_and_ancestors.should == [tags(:child), tags(:parent), tags(:grandparent)]
+      end
+
+      it "should assemble descendants correctly" do
+        tags(:parent).descendants.should == [tags(:child)]
+        tags(:parent).self_and_descendants.should == [tags(:parent), tags(:child)]
+        tags(:grandparent).descendants.should == [tags(:parent), tags(:child)]
+        tags(:grandparent).self_and_descendants.should == [tags(:grandparent), tags(:parent), tags(:child)]
+        tags(:grandparent).self_and_descendants.collect { |t| t.name }.join(" > ").should == "grandparent > parent > child"
+      end
+    end
+
+    context "paths" do
+
+      it "should build ancestry path" do
+        tags(:child).ancestry_path.should == %w{grandparent parent child}
+        tags(:child).ancestry_path(:name).should == %w{grandparent parent child}
+        tags(:child).ancestry_path(:title).should == %w{Nonnie Mom Kid}
+      end
+
+      it "should find by path" do
+        # class method:
+        Tag.find_by_path(%w{grandparent parent child}).should == tags(:child)
+        # instance method:
+        tags(:parent).find_by_path(%w{child}).should == tags(:child)
+        tags(:grandparent).find_by_path(%w{parent child}).should == tags(:child)
+        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:
+        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}
+        # instance method:
+        a.find_or_create_by_path(%w{b c}).ancestry_path.should == %w{a b c}
+      end
+    end
+
+    def validate_city_tag city
+      tags(:california).children.include?(city).should_not be_nil
+      city.ancestors.should == [tags(:california), tags(:united_states), tags(:places)]
+      city.self_and_ancestors.should == [city, tags(:california), tags(:united_states), tags(:places)]
     end
 
-    it "should prevent parental loops from toes" do
-      @leaf.children << @root
-      @root.valid?.should be_false
-      @leaf.reload.children.should be_empty
-    end
-    
-    it "should support reparenting" do
-      @root.children << @leaf
-      Tag.leaves.should =~ [@leaf, @mid]
-    end
   end
 end
 
 describe Tag do
+  it_behaves_like Tag
+end
 
-  fixtures :tags
-
-  before :each do
-    Tag.rebuild!
-  end
-
-  context "class injection" do
-    it "should build hierarchy classname correctly" do
-      Tag.hierarchy_class.to_s.should == "TagHierarchy"
-      Tag.hierarchy_class_name.should == "TagHierarchy"
-    end
-
-    it "should have a correct parent column name" do
-      Tag.parent_column_name.should == "parent_id"
-    end
-  end
-
-  context "roots" do
-    it "should find global roots" do
-      roots = Tag.roots.to_a
-      roots.should be_member(tags(:people))
-      roots.should be_member(tags(:events))
-      roots.should_not be_member(tags(:child))
-      tags(:people).root?.should be_true
-      tags(:child).root?.should be_false
-    end
-
-    it "should find an instance root" do
-      tags(:grandparent).root.should == tags(:grandparent)
-      tags(:parent).root.should == tags(:grandparent)
-      tags(:child).root.should == tags(:grandparent)
-    end
-  end
-
-  context "leaves" do
-    it "should assemble global leaves" do
-      Tag.leaves.size.should > 0
-      Tag.leaves.each { |t| t.children.should be_empty, "#{t.name} was returned by leaves but has children: #{t.children}" }
-      Tag.leaves.each { |t| t.should be_leaf, "{t.name} was returned by leaves but was not a leaf" }
-    end
-
-    it "should assemble instance leaves" do
-      tags(:grandparent).leaves.should == [tags(:child)]
-      tags(:parent).leaves.should == [tags(:child)]
-      tags(:child).leaves.should == [tags(:child)]
-    end
-  end
-
-  context "adding children" do
-    it "should work explicitly" do
-      sb = Tag.create!(:name => "Santa Barbara")
-      sb.leaf?.should_not be_nil
-      tags(:california).add_child sb
-      sb.leaf?.should_not be_nil
-      validate_city_tag sb
-    end
-
-    it "should work implicitly through the collection" do
-      eg = Tag.create!(:name => "El Granada")
-      eg.leaf?.should_not be_nil
-      tags(:california).children << eg
-      eg.leaf?.should_not be_nil
-      validate_city_tag eg
-    end
-
-    it "should fail to create ancestor loops" do
-      child = tags(:child)
-      parent = child.parent
-      child.add_child(parent) # this should fail
-      parent.valid?.should be_false
-      child.reload.children.should be_empty
-      parent.reload.children.should =~ [child]
-    end
-
-    it "should move non-leaves" do
-      # This is what the fixture should encode:
-      tags(:d2).ancestry_path.should == %w{a1 b2 c2 d2}
-      tags(:b1).add_child(tags(:c2))
-      tags(:b2).leaf?.should_not be_nil
-      tags(:b1).children.include?(tags(:c2)).should_not be_nil
-      tags(:d2).reload.ancestry_path.should == %w{a1 b1 c2 d2}
-    end
-
-    it "should move leaves" do
-      l = Tag.find_or_create_by_path(%w{leaftest branch1 leaf})
-      b2 = Tag.find_or_create_by_path(%w{leaftest branch2})
-      b2.children << l
-      l.ancestry_path.should == %w{leaftest branch2 leaf}
-    end
-
-    it "should move roots" do
-      l1 = Tag.find_or_create_by_path(%w{roottest1 branch1 leaf1})
-      l2 = Tag.find_or_create_by_path(%w{roottest2 branch2 leaf2})
-      l1.children << l2.root
-      l1.ancestry_path.should == %w{roottest1 branch1 leaf1}
-      l2.ancestry_path.should == %w{roottest1 branch1 leaf1 roottest2 branch2 leaf2}
-    end
-
-    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 }
-      b2.destroy
-      entities.each { |e| Tag.find_by_id(e.id).should be_nil }
-      DestroyedTag.all.collect { |t| t.name }.should =~ names
-    end
-  end
-
-  context "injected attributes" do
-    it "should compute level correctly" do
-      tags(:grandparent).level.should == 0
-      tags(:parent).level.should == 1
-      tags(:child).level.should == 2
-    end
-
-    it "should determine parent correctly" do
-      tags(:grandparent).parent.should == nil
-      tags(:parent).parent.should == tags(:grandparent)
-      tags(:child).parent.should == tags(:parent)
-    end
-
-    it "should have a sane children collection" do
-      tags(:grandparent).children.include? tags(:parent).should_not be_nil
-      tags(:parent).children.include? tags(:child).should_not be_nil
-      tags(:child).children.empty?.should_not be_nil
-    end
-
-    it "should assemble ancestors correctly" do
-      tags(:child).ancestors.should == [tags(:parent), tags(:grandparent)]
-      tags(:child).self_and_ancestors.should == [tags(:child), tags(:parent), tags(:grandparent)]
-    end
-
-    it "should assemble descendants correctly" do
-      tags(:parent).descendants.should == [tags(:child)]
-      tags(:parent).self_and_descendants.should == [tags(:parent), tags(:child)]
-      tags(:grandparent).descendants.should == [tags(:parent), tags(:child)]
-      tags(:grandparent).self_and_descendants.should == [tags(:grandparent), tags(:parent), tags(:child)]
-      tags(:grandparent).self_and_descendants.collect { |t| t.name }.join(" > ").should == "grandparent > parent > child"
-    end
-  end
-
-  context "paths" do
-
-    it "should build ancestry path" do
-      tags(:child).ancestry_path.should == %w{grandparent parent child}
-      tags(:child).ancestry_path(:name).should == %w{grandparent parent child}
-      tags(:child).ancestry_path(:title).should == %w{Nonnie Mom Kid}
-    end
-
-    it "should find by path" do
-      # class method:
-      Tag.find_by_path(%w{grandparent parent child}).should == tags(:child)
-      # instance method:
-      tags(:parent).find_by_path(%w{child}).should == tags(:child)
-      tags(:grandparent).find_by_path(%w{parent child}).should == tags(:child)
-      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:
-      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}
-      # instance method:
-      a.find_or_create_by_path(%w{b c}).ancestry_path.should == %w{a b c}
-    end
-  end
-
-  def validate_city_tag city
-    tags(:california).children.include?(city).should_not be_nil
-    city.ancestors.should == [tags(:california), tags(:united_states), tags(:places)]
-    city.self_and_ancestors.should == [city, tags(:california), tags(:united_states), tags(:places)]
+describe "Tag with AR whitelisted attributes enabled" do
+  before(:all) do
+    ActiveRecord::Base.attr_accessible(nil) # turn on whitelisted attributes
+    ActiveRecord::Base.subclasses.each{|ea|ea.reset_column_information}
   end
-
+  it_behaves_like Tag
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: closure_tree
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 3
   - 0
-  - 2
-  version: 3.0.2
+  - 3
+  version: 3.0.3
 platform: ruby
 authors: 
 - Matthew McEachen
@@ -15,11 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-07 00:00:00 Z
+date: 2012-03-11 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  type: :runtime
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,8 +30,121 @@ dependencies:
         - 0
         - 0
         version: 3.0.0
-  name: activerecord
   version_requirements: *id001
+  name: activerecord
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id002
+  name: rake
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id003
+  name: yard
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id004
+  name: rspec
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id005
+  name: rails
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id006
+  name: rspec-rails
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id007
+  name: mysql2
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id008
+  name: pg
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id009
+  name: sqlite3
+  type: :development
 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
@@ -46,7 +158,6 @@ files:
 - lib/closure_tree/acts_as_tree.rb
 - lib/closure_tree/version.rb
 - lib/closure_tree.rb
-- lib/tasks/closure_tree_tasks.rake
 - MIT-LICENSE
 - Rakefile
 - README.md
@@ -87,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Hierarchies for ActiveRecord models using a Closure Tree storage algorithm

data/lib/tasks/closure_tree_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :closure_tree do
-#   # Task goes here
-# end