closure_tree 4.0.1 → 4.1.0

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = "4.0.1" unless defined?(::ClosureTree::VERSION)
+  VERSION = Gem::Version.new("4.1.0") unless defined?(::ClosureTree::VERSION)
 end

data/spec/db/schema.rb

@@ -26,17 +26,17 @@ ActiveRecord::Schema.define(:version => 0) do
     t.integer "generations", :null => false
   end
 
-  create_table "tags_uuid", :id => false, :force => true do |t|
-    t.string "id", :unique => true
+  create_table "uuid_tags", :id => false, :force => true do |t|
+    t.string "uuid", :unique => true
     t.string "name"
     t.string "title"
-    t.string "parent_id"
+    t.string "parent_uuid"
     t.integer "sort_order"
     t.datetime "created_at"
     t.datetime "updated_at"
   end
 
-  create_table "tag_hierarchies_uuid", :id => false, :force => true do |t|
+  create_table "uuid_tag_hierarchies", :id => false, :force => true do |t|
     t.string "ancestor_id", :null => false
     t.string "descendant_id", :null => false
     t.integer "generations", :null => false

data/spec/label_spec.rb

@@ -123,10 +123,10 @@ describe Label do
         end
         roots = classes.first.roots
         i = instances.shift
-        roots.should =~ [i]
+        roots.to_a.should =~ [i]
         while (!instances.empty?) do
           child = instances.shift
-          i.children.should =~ [child]
+          i.children.to_a.should =~ [child]
           i = child
         end
       end
@@ -353,7 +353,7 @@ describe Label do
       labels(:c2).append_sibling(labels(:e2))
       labels(:e2).self_and_siblings.to_a.should == [labels(:b1), labels(:b2), labels(:c2), labels(:e2)]
       labels(:a1).self_and_descendants.collect(&:name).should == %w(a1 b1 b2 c2 e2 d2 c1-six c1-seven c1-eight c1-nine)
-      labels(:a1).leaves.collect(&:name).should == %w(b2 e2 d2 c1-six c1-seven c1-eight c1-nine)
+      labels(:a1).leaves.collect(&:name).should =~ %w(b2 e2 d2 c1-six c1-seven c1-eight c1-nine)
     end
   end
 

data/spec/parallel_spec.rb

@@ -1,5 +1,12 @@
 require 'spec_helper'
 
+parallelism_is_broken = begin
+  # Rails < 3.2 has known bugs with parallelism
+  (ActiveRecord::VERSION::MAJOR <= 3 && ActiveRecord::VERSION::MINOR < 2) ||
+  # SQLite doesn't support parallel writes
+  ENV["DB"] =~ /sqlite/
+end
+
 describe "threadhot" do
 
   before :each do
@@ -34,7 +41,7 @@ describe "threadhot" do
     Tag.roots.collect { |ea| ea.name.to_i }.should =~ @times
     # No dupe children:
     %w(a b c).each do |ea|
-      Tag.find_all_by_name(ea).size.should == @iterations
+      Tag.where(:name => ea).size.should == @iterations
     end
   end
 
@@ -42,9 +49,9 @@ describe "threadhot" do
     @parent = Tag.create!(:name => "root")
     run_workers
     @parent.reload.children.collect { |ea| ea.name.to_i }.should =~ @times
-    Tag.find_all_by_name(@names).size.should == @iterations
+    Tag.where(:name => @names).size.should == @iterations
     %w(a b c).each do |ea|
-      Tag.find_all_by_name(ea).size.should == @iterations
+      Tag.where(:name => ea).size.should == @iterations
     end
   end
 
@@ -52,8 +59,7 @@ describe "threadhot" do
     # disable with_advisory_lock:
     Tag.should_receive(:with_advisory_lock).any_number_of_times { |lock_name, &block| block.call }
     run_workers
-    Tag.find_all_by_name(@names).size.should > @iterations
+    Tag.where(:name => @names).size.should > @iterations
   end
 
-# SQLite doesn't like parallelism, and Rails 3.0 and 3.1 have known threading issues. SKIP.
-end if ((ENV["DB"] != "sqlite") && (ActiveRecord::VERSION::STRING =~ /^3.2/))
+end unless parallelism_is_broken

data/spec/spec_helper.rb

@@ -2,12 +2,14 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 plugin_test_dir = File.dirname(__FILE__)
 
 require 'rubygems'
-require 'bundler/setup'
-
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
 require 'rspec'
-require 'logger'
-
-require 'action_controller' # rspec-rails needs this :(
+require 'rails'
+require 'active_record'
+require 'active_record/fixtures'
+require 'rspec/rails/adapters'
+require 'rspec/rails/fixture_support'
 require 'closure_tree'
 require 'tmpdir'
 
@@ -20,12 +22,31 @@ require 'erb'
 ENV["DB"] ||= "mysql"
 ActiveRecord::Base.table_name_prefix = ENV['DB_PREFIX'].to_s
 ActiveRecord::Base.table_name_suffix = ENV['DB_SUFFIX'].to_s
+
+if ENV['ATTR_ACCESSIBLE'] == '1'
+  # turn on whitelisted attributes:
+  ActiveRecord::Base.send(:include, ActiveModel::MassAssignmentSecurity)
+end
+
 ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result)
 ActiveRecord::Base.establish_connection(ENV["DB"])
 ActiveRecord::Migration.verbose = false
 require 'db/schema'
 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
+
+class Hash
+  def render_from_yield(&block)
+    inject({}) do |h, entry|
+      k, v = entry
+      h[block.call(k)] = if v.is_a?(Hash) then
+        v.render_from_yield(&block)
+      else
+        block.call(v)
+      end
+      h
+    end
+  end
+end
 
 DB_QUERIES = []
 

data/spec/support/models.rb

@@ -3,7 +3,26 @@ require 'uuidtools'
 class Tag < ActiveRecord::Base
   acts_as_tree :dependent => :destroy, :order => "name"
   before_destroy :add_destroyed_tag
-  attr_accessible :name
+  attr_accessible :name if _ct.use_attr_accessible?
+  def to_s
+    name
+  end
+  def add_destroyed_tag
+    # Proof for the tests that the destroy rather than the delete method was called:
+    DestroyedTag.create(:name => name)
+  end
+end
+
+class UUIDTag < ActiveRecord::Base
+  self.primary_key = :uuid
+  before_create :set_uuid
+  acts_as_tree :dependent => :destroy, :order => 'name', :parent_column_name => 'parent_uuid'
+  before_destroy :add_destroyed_tag
+  attr_accessible :name if _ct.use_attr_accessible?
+
+  def set_uuid
+    self.uuid = UUIDTools::UUID.timestamp_create.to_s
+  end
 
   def to_s
     name
@@ -15,8 +34,10 @@ class Tag < ActiveRecord::Base
   end
 end
 
+USE_ATTR_ACCESSIBLE = Tag._ct.use_attr_accessible?
+
 class DestroyedTag < ActiveRecord::Base
-  attr_accessible :name
+  attr_accessible :name if USE_ATTR_ACCESSIBLE
 end
 
 class User < ActiveRecord::Base
@@ -31,7 +52,7 @@ class User < ActiveRecord::Base
     Contract.where(:user_id => descendant_ids)
   end
 
-  attr_accessible :email, :referrer
+  attr_accessible :email, :referrer if USE_ATTR_ACCESSIBLE
 
   def to_s
     email
@@ -43,7 +64,8 @@ class Contract < ActiveRecord::Base
 end
 
 class Label < ActiveRecord::Base
-  attr_accessible :name # <- make sure order doesn't matter
+  # make sure order doesn't matter
+  attr_accessible :name if USE_ATTR_ACCESSIBLE
   acts_as_tree :order => :sort_order, # <- LOOK IT IS A SYMBOL OMG
     :parent_column_name => "mother_id",
     :dependent => :destroy
@@ -69,6 +91,6 @@ end
 module Namespace
   class Type < ActiveRecord::Base
     acts_as_tree :dependent => :destroy
-    attr_accessible :name
+    attr_accessible :name if _ct.use_attr_accessible?
   end
 end

data/spec/tag_examples.rb

@@ -0,0 +1,421 @@
+require 'spec_helper'
+
+shared_examples_for "Tag (without fixtures)" do
+
+  let (:tag_class) { described_class }
+  let (:tag_hierarchy_class) { described_class.hierarchy_class }
+
+  context 'class setup' do
+
+    it 'has correct accessible_attributes' do
+      if tag_class._ct.use_attr_accessible?
+        tag_class.accessible_attributes.to_a.should =~ %w(parent name)
+      end
+    end
+
+    it 'should build hierarchy classname correctly' do
+      tag_class.hierarchy_class.should == tag_hierarchy_class
+      tag_class._ct.hierarchy_class_name.should == tag_hierarchy_class.to_s
+      tag_class._ct.short_hierarchy_class_name.should == tag_hierarchy_class.to_s
+    end
+
+    it 'should have a correct parent column name' do
+      expected_parent_column_name = tag_class == UUIDTag ? "parent_uuid" : "parent_id"
+      tag_class._ct.parent_column_name.should == expected_parent_column_name
+    end
+  end
+
+  describe "from empty db" do
+    def nuke_db
+      tag_hierarchy_class.delete_all
+      tag_class.delete_all
+    end
+
+    before :each do
+      nuke_db
+    end
+
+    context "with no tags" do
+      it "should return no entities" do
+        tag_class.roots.should be_empty
+        tag_class.leaves.should be_empty
+      end
+    end
+
+    context "with 1 tag" do
+      it "should return the only entity as a root and leaf" do
+        a = tag_class.create!(:name => "a")
+        tag_class.roots.should == [a]
+        tag_class.leaves.should == [a]
+      end
+    end
+
+    context "with 2 tags" do
+      before :each do
+        @root = tag_class.create!(:name => "root")
+        @leaf = @root.add_child(tag_class.create!(:name => "leaf"))
+      end
+      it "should return a simple root and leaf" do
+        tag_class.roots.should == [@root]
+        tag_class.leaves.should == [@leaf]
+      end
+      it "should return child_ids for root" do
+        @root.child_ids.should == [@leaf.id]
+      end
+      it "should return an empty array for leaves" do
+        @leaf.child_ids.should be_empty
+      end
+    end
+
+    context "3 tag collection.create db" do
+      before :each do
+        @root = tag_class.create! :name => "root"
+        @mid = @root.children.create! :name => "mid"
+        @leaf = @mid.children.create! :name => "leaf"
+        DestroyedTag.delete_all
+      end
+
+      it "should create all tags" do
+        tag_class.all.to_a.should =~ [@root, @mid, @leaf]
+      end
+
+      it "should return a root and leaf without middle tag" do
+        tag_class.roots.should == [@root]
+        tag_class.leaves.should == [@leaf]
+      end
+
+      it "should delete leaves" do
+        tag_class.leaves.destroy_all
+        tag_class.roots.should == [@root] # untouched
+        tag_class.leaves.should == [@mid]
+      end
+
+      it "should delete everything if you delete the roots" do
+        tag_class.roots.destroy_all
+        tag_class.all.should be_empty
+        tag_class.roots.should be_empty
+        tag_class.leaves.should be_empty
+        DestroyedTag.all.map { |t| t.name }.should =~ %w{root mid leaf}
+      end
+    end
+
+    context "3 tag explicit_create db" do
+      before :each do
+        @root = tag_class.create!(:name => "root")
+        @mid = @root.add_child(tag_class.create!(:name => "mid"))
+        @leaf = @mid.add_child(tag_class.create!(:name => "leaf"))
+      end
+
+      it "should create all tags" do
+        tag_class.all.to_a.should =~ [@root, @mid, @leaf]
+      end
+
+      it "should return a root and leaf without middle tag" do
+        tag_class.roots.should == [@root]
+        tag_class.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 re-parenting" do
+        @root.children << @leaf
+        tag_class.leaves.should == [@leaf, @mid]
+      end
+
+      it "cleans up hierarchy references for leaves" do
+        @leaf.destroy
+        tag_hierarchy_class.where(:ancestor_id => @leaf.id).should be_empty
+        tag_hierarchy_class.where(:descendant_id => @leaf.id).should be_empty
+      end
+
+      it "cleans up hierarchy references" do
+        @mid.destroy
+        tag_hierarchy_class.where(:ancestor_id => @mid.id).should be_empty
+        tag_hierarchy_class.where(:descendant_id => @mid.id).should be_empty
+        @root.reload.should be_root
+        root_hiers = @root.ancestor_hierarchies.to_a
+        root_hiers.size.should == 1
+        tag_hierarchy_class.where(:ancestor_id => @root.id).should == root_hiers
+        tag_hierarchy_class.where(:descendant_id => @root.id).should == root_hiers
+      end
+
+      it "should have different hash codes for each hierarchy model" do
+        hashes = tag_hierarchy_class.all.map(&:hash)
+        hashes.should =~ hashes.uniq
+      end
+
+      it "should return the same hash code for equal hierarchy models" do
+        tag_hierarchy_class.first.hash.should == tag_hierarchy_class.first.hash
+      end
+    end
+
+    it "performs as the readme says it does" do
+      grandparent = tag_class.create(:name => 'Grandparent')
+      parent = grandparent.children.create(:name => 'Parent')
+      child1 = tag_class.create(:name => 'First Child', :parent => parent)
+      child2 = tag_class.new(:name => 'Second Child')
+      parent.children << child2
+      child3 = tag_class.new(:name => 'Third Child')
+      parent.add_child child3
+      grandparent.self_and_descendants.collect(&:name).should ==
+        ["Grandparent", "Parent", "First Child", "Second Child", "Third Child"]
+      child1.ancestry_path.should ==
+        ["Grandparent", "Parent", "First Child"]
+      child3.ancestry_path.should ==
+        ["Grandparent", "Parent", "Third Child"]
+      d = tag_class.find_or_create_by_path %w(a b c d)
+      h = tag_class.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
+
+    it "roots sort alphabetically" do
+      expected = ("a".."z").to_a
+      expected.shuffle.each { |ea| tag_class.create!(:name => ea) }
+      tag_class.roots.collect { |ea| ea.name }.should == expected
+    end
+
+    context "with simple tree" do
+      before :each do
+        tag_class.find_or_create_by_path %w(a1 b1 c1a)
+        tag_class.find_or_create_by_path %w(a1 b1 c1b)
+        tag_class.find_or_create_by_path %w(a2 b2)
+        tag_class.find_or_create_by_path %w(a3)
+
+        @a1, @a2, @a3, @b1, @b2, @c1a, @c1b = tag_class.where(:name => %w(a1 a2 a3 b1 b2 c1a c1b)).reorder(:name).to_a
+        @expected_roots = [@a1, @a2, @a3]
+        @expected_leaves = [@c1a, @c1b, @b2, @a3]
+      end
+      it 'should find global roots' do
+        tag_class.roots.to_a.should =~ @expected_roots
+      end
+      it 'should return root? for roots' do
+        @expected_roots.each { |ea| ea.should be_root }
+      end
+      it 'should not return root? for non-roots' do
+        [@b1, @b2, @c1a, @c1b].each { |ea| ea.should_not be_root }
+      end
+      it 'should return the correct root' do
+        {@a1 => @a1, @a2 => @a2, @a3 => @a3,
+          @b1 => @a1, @b2 => @a2, @c1a => @a1, @c1b => @a1}.each do |node, root|
+          node.root.should == root
+        end
+      end
+      it 'should assemble global leaves' do
+        tag_class.leaves.to_a.should =~ @expected_leaves
+      end
+      it 'should assemble instance leaves' do
+        {@a1 => [@c1a, @c1b], @b1 => [@c1a, @c1b], @a2 => [@b2]}.each do |node, leaves|
+          node.leaves.to_a.should == leaves
+        end
+        @expected_leaves.each { |ea| ea.leaves.to_a.should == [ea] }
+      end
+      it 'should return leaf? for leaves' do
+        @expected_leaves.each { |ea| ea.should be_leaf }
+      end
+    end
+
+    context "paths" do
+      before :each do
+        @child = tag_class.find_or_create_by_path(%w(grandparent parent child))
+        @child.title = "Kid"
+        @parent = @child.parent
+        @parent.title = "Mom"
+        @grandparent = @parent.parent
+        @grandparent.title = "Nonnie"
+        [@child, @parent, @grandparent].each { |ea| ea.save! }
+      end
+
+      it "should build ancestry path" do
+        @child.ancestry_path.should == %w{grandparent parent child}
+        @child.ancestry_path(:name).should == %w{grandparent parent child}
+        @child.ancestry_path(:title).should == %w{Nonnie Mom Kid}
+      end
+
+      it "should find by path" do
+        # class method:
+        tag_class.find_by_path(%w{grandparent parent child}).should == @child
+        # instance method:
+        @parent.find_by_path(%w{child}).should == @child
+        @grandparent.find_by_path(%w{parent child}).should == @child
+        @parent.find_by_path(%w{child larvae}).should be_nil
+      end
+
+      it "finds correctly rooted paths" do
+        decoy = tag_class.find_or_create_by_path %w(a b c d)
+        b_d = tag_class.find_or_create_by_path %w(b c d)
+        tag_class.find_by_path(%w(b c d)).should == b_d
+        tag_class.find_by_path(%w(c d)).should be_nil
+      end
+
+      it "find_by_path for 1 node" do
+        b = tag_class.find_or_create_by_path %w(a b)
+        b2 = b.root.find_by_path(%w(b))
+        b2.should == b
+      end
+
+      it "find_by_path for 2 nodes" do
+        c = tag_class.find_or_create_by_path %w(a b c)
+        c.root.find_by_path(%w(b c)).should == c
+        c.root.find_by_path(%w(a c)).should be_nil
+        c.root.find_by_path(%w(c)).should be_nil
+      end
+
+      it "find_by_path for 3 nodes" do
+        d = tag_class.find_or_create_by_path %w(a b c d)
+        d.root.find_by_path(%w(b c d)).should == d
+        tag_class.find_by_path(%w(a b c d)).should == d
+        tag_class.find_by_path(%w(d)).should be_nil
+      end
+
+      it "should return nil for missing nodes" do
+        tag_class.find_by_path(%w{missing}).should be_nil
+        tag_class.find_by_path(%w{grandparent missing}).should be_nil
+        tag_class.find_by_path(%w{grandparent parent missing}).should be_nil
+        tag_class.find_by_path(%w{grandparent parent missing child}).should be_nil
+      end
+
+      it "should find or create by path" do
+        # class method:
+        grandparent = tag_class.find_or_create_by_path(%w{grandparent})
+        grandparent.should == @grandparent
+        child = tag_class.find_or_create_by_path(%w{grandparent parent child})
+        child.should == @child
+        tag_class.find_or_create_by_path(%w{events anniversary}).ancestry_path.should == %w{events anniversary}
+        a = tag_class.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
+
+    context "hash_tree" do
+
+      before :each do
+        @b = tag_class.find_or_create_by_path %w(a b)
+        @a = @b.parent
+        @b2 = tag_class.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_class.hash_tree(:limit_depth => 0).should == {}
+        end
+        it "limit_depth 1" do
+          tag_class.hash_tree(:limit_depth => 1).should == {@a => {}}
+        end
+        it "limit_depth 2" do
+          tag_class.hash_tree(:limit_depth => 2).should == {@a => {@b => {}, @b2 => {}}}
+        end
+        it "limit_depth 3" do
+          tag_class.hash_tree(:limit_depth => 3).should == {@a => {@b => {@c1 => {}, @c2 => {}}, @b2 => {}}}
+        end
+        it "limit_depth 4" do
+          tag_class.hash_tree(:limit_depth => 4).should == @full_tree
+        end
+        it "no limit holdum" do
+          tag_class.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_class.hash_tree_scope(ea))
+          end
+        end
+        it "no limit holdum" do
+          assert_no_dupes(tag_class.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
+
+    describe 'DOT rendering' do
+      it 'should render for an empty scope' do
+        tag_class.to_dot_digraph(tag_class.where("0=1")).should == "digraph G {\n}\n"
+      end
+      it 'should render for an empty scope' do
+        tag_class.find_or_create_by_path(%w(a b1 c1))
+        tag_class.find_or_create_by_path(%w(a b2 c2))
+        tag_class.find_or_create_by_path(%w(a b2 c3))
+        a, b1, b2, c1, c2, c3 = %w(a b1 b2 c1 c2 c3).map { |ea| tag_class.where(:name => ea).first.id }
+        dot = tag_class.roots.first.to_dot_digraph
+        dot.should == <<-DOT
+digraph G {
+  #{a} [label="a"]
+  #{a} -> #{b1}
+  #{b1} [label="b1"]
+  #{a} -> #{b2}
+  #{b2} [label="b2"]
+  #{b1} -> #{c1}
+  #{c1} [label="c1"]
+  #{b2} -> #{c2}
+  #{c2} [label="c2"]
+  #{b2} -> #{c3}
+  #{c3} [label="c3"]
+}
+        DOT
+      end
+    end
+  end
+end