closure_tree 1.0.0 → 2.0.0.beta1

data/lib/closure_tree/version.rb

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

data/spec/db/database.yml

@@ -0,0 +1,18 @@
+sqlite3:
+  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
+  database: closure_tree.sqlite3.db
+sqlite3mem:
+  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
+  database: ":memory:"
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: closure_tree_plugin_test
+  min_messages: ERROR
+mysql:
+  adapter: mysql2
+  host: localhost
+  username: root
+  password:
+  database: closure_tree_plugin_test

data/spec/db/schema.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+ActiveRecord::Schema.define(:version => 0) do
+
+  create_table "tags", :force => true do |t|
+    t.string   "name"
+    t.string   "title"
+    t.integer  "parent_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "tag_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
+
+  create_table "destroyed_tags", :force => true do |t|
+    t.string   "name"
+  end
+
+  add_index :tag_hierarchies, [:ancestor_id, :descendant_id], :unique => true
+  add_index :tag_hierarchies, [:descendant_id]
+
+  create_table "users", :force => true do |t|
+    t.string   "email"
+    t.integer  "referrer_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "referral_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 :referral_hierarchies, [:ancestor_id, :descendant_id], :unique => true
+  add_index :referral_hierarchies, [:descendant_id]
+end

data/{test/dummy/test → spec}/fixtures/tags.yml

@@ -12,7 +12,7 @@ parent:
 child:
   name: child
   parent: parent
-  title: Kid 
+  title: Kid
 
 people:
   name: people
@@ -61,3 +61,36 @@ san_francisco:
   name: san_francisco
   parent: california
 
+
+# Move and deletion test tree
+
+a1:
+  name: a1
+
+b1:
+  name: b1
+  parent: a1
+
+b2:
+  name: b2
+  parent: a1
+
+c1a:
+  name: c1a
+  parent: b1
+
+c1b:
+  name: c1b
+  parent: b1
+
+c2:
+  name: c2
+  parent: b2
+
+d2:
+  name: d2
+  parent: c2
+
+e2:
+  name: e2
+  parent: d2

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+plugin_test_dir = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'logger'
+
+require 'active_support'
+require 'active_model'
+require 'active_record'
+require 'action_controller'
+
+require 'closure_tree'
+
+ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
+
+require 'yaml'
+require 'erb'
+ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result)
+ActiveRecord::Base.establish_connection(ENV["DB"] || "mysql")
+ActiveRecord::Migration.verbose = false
+load(File.join(plugin_test_dir, "db", "schema.rb"))
+
+require 'support/models'
+
+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
+  # see what's going on while debuggering with different db connections.
+  config.use_transactional_fixtures = false
+end

data/spec/support/models.rb

@@ -0,0 +1,26 @@
+class Tag < ActiveRecord::Base
+  acts_as_tree :dependent => :destroy
+  before_destroy :create_tag
+
+  def to_s
+    name
+  end
+
+  def create_tag
+    # Proof for the tests that the destroy rather than the delete method was called:
+    DestroyedTag.create(:name => name)
+  end
+end
+
+class DestroyedTag < ActiveRecord::Base
+end
+
+class User < ActiveRecord::Base
+  acts_as_tree :parent_column_name => "referrer_id",
+    :name_column => 'email',
+    :hierarchy_table_name => 'referral_hierarchies'
+
+  def to_s
+    email
+  end
+end

data/spec/tag_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe "empty db" do
+
+  def nuke
+    Tag.delete_all
+    TagHierarchy.delete_all
+    DestroyedTag.delete_all
+  end
+
+  before :each do
+    nuke
+  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" do
+      lambda do
+        @mid.children << @root
+      end.should raise_error
+
+      lambda do
+        @leaf.children << @root
+      end.should raise_error
+    end
+
+    it "should support reparenting" do
+      @root.children << @leaf
+      Tag.leaves.should =~ [@leaf, @mid]
+    end
+  end
+end
+
+describe Tag do
+
+  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
+      lambda do
+        tags(:child).add_child(tags(:grandparent))
+      end.should raise_error
+    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 find or create by path" do
+      # class method:
+      Tag.find_or_create_by_path(%w{grandparent parent 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
+
+end
+