closure_tree 4.2.9 → 4.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTg4Mjc4NzJlYTM4ZTU4MTE5NzVhNzJlOTc1ZWMyNjAwYjk5NTU2Zg==
+    Y2I0ZTRhYzcwYzQ4YmM1MmIxMjUxZTdkZDdlMzY4NzkxNGEwMzM5OA==
   data.tar.gz: !binary |-
-    ZjBiMGUzZWUxZGI3MTI3N2Y4YTYwNGQ1ODJlYzQzNDVkYWViZGY3Nw==
+    MDQ3YzAyNjA4NzI4YjgwM2JkYzgzYzlhYThhYTRkNmMxNjdhZDYxYg==
 SHA512:
   metadata.gz: !binary |-
-    OTYyMDY4MDA0MmUzNTUwOGJmNTdjODVkMzU1MTMwMjNkZDhhNDA1MWUyYmQ4
-    NzEzOWY2OGE2MDdjYzNlZWJmYjFiZmQ0N2I0ZmI5MjU1ZjA2YzExYjI5NmM2
-    NjVjNjE0MjQ3N2U3M2I2NDU3ZGI5ZDRhZGNhM2U4ZmRjNmE0NDU=
+    OTVlZGNkNzlhN2Q3ODkxYzJjMTQ2YzNkZjA1MGI4ZDhhNDM4NTU2ZTRlZDEw
+    NjYxOWZjMDViNmJlNTE4NjM3ZDQ2MTM5Yjg1ZTkxNjAyNTBhMTU2N2FmNzRi
+    ZTQ5NmRlNjZlYzRjZGViYzU2OTBiZGY5YzQ4MTYxNmZkMTEwYmE=
   data.tar.gz: !binary |-
-    MWUxMjMxN2MyZDEzNGZjYzY5OTE5ZjJkYTNlNTQ3MzFhNWI2MTU3OTA3ZWUz
-    YjVmM2UxY2Q4NjhlOGUyMjFiMjFhNGYzYjY5MzIwZTk2NWI2ZDQ5ZmY4NWI0
-    MjIwZmRmMTgxNWNmMTIzYzkzNWY1ZmRlMTIzMGY4NmUxYzRlMjI=
+    MmQ3OTBkNDZhNDkyZjZmY2E2NDRiZWRmYzc4YzA4Y2FjMTRmNTQwZTFmZjBl
+    Y2UwNGRiNDk2MTVhMGY5ZGNmNjZkMGY1MGI5NGYzNmNkYjRjMjJjZGM0NWNj
+    YmEyN2FkYjlkZDAxNWU3MWM4NGY0ZTk4MTQ1ZmFiM2UzNjVhNjE=

data/README.md

@@ -387,7 +387,7 @@ If your ```order``` column is an integer attribute, you'll also have these:
 ```ruby
 
 root = OrderedTag.create(:name => "root")
-a = OrderedTag.create(:name => "a", :parent => "root")
+a = OrderedTag.create(:name => "a", :parent => root)
 b = OrderedTag.create(:name => "b")
 c = OrderedTag.create(:name => "c")
 

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = Gem::Version.new('4.2.9') unless defined?(::ClosureTree::VERSION)
+  VERSION = Gem::Version.new('4.3.0') unless defined?(::ClosureTree::VERSION)
 end

data/spec/db/database.yml

@@ -1,19 +1,21 @@
+common: &common
+  database: closure_tree_test
+  host: localhost
+  pool: 50
+  timeout: 5000
+  reaping_frequency: 1000
+  min_messages: ERROR
+
 sqlite:
   adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
   database: spec/sqlite3.db
-  pool: 50
-  timeout: 5000
 
 postgresql:
+  <<: *common
   adapter: postgresql
   username: postgres
-  database: closure_tree_test
-  min_messages: ERROR
-  pool: 50
 
 mysql:
+  <<: *common
   adapter: mysql2
-  host: localhost
   username: root
-  database: closure_tree_test
-  pool: 50

data/spec/db/schema.rb

@@ -1,17 +1,8 @@
 # encoding: UTF-8
-class ActiveRecord::ConnectionAdapters::AbstractAdapter
-  def force_add_index(table_name, columns, options = {})
-    begin
-      remove_index!(table_name, options[:name])
-    rescue ActiveRecord::StatementInvalid, ArgumentError
-    end
-    add_index table_name, columns, options
-  end
-end
 
 ActiveRecord::Schema.define(:version => 0) do
 
-  create_table "tags", :force => true do |t|
+  create_table "tags" do |t|
     t.string "name"
     t.string "title"
     t.integer "parent_id"
@@ -20,13 +11,18 @@ ActiveRecord::Schema.define(:version => 0) do
     t.datetime "updated_at"
   end
 
-  create_table "tag_hierarchies", :id => false, :force => true do |t|
+  add_foreign_key(:tags, :tags, :column => 'parent_id')
+
+  create_table "tag_hierarchies", :id => false do |t|
     t.integer "ancestor_id", :null => false
     t.integer "descendant_id", :null => false
     t.integer "generations", :null => false
   end
 
-  create_table "uuid_tags", :id => false, :force => true do |t|
+  add_foreign_key(:tag_hierarchies, :tags, :column => 'ancestor_id')
+  add_foreign_key(:tag_hierarchies, :tags, :column => 'descendant_id')
+
+  create_table "uuid_tags", :id => false do |t|
     t.string "uuid", :unique => true
     t.string "name"
     t.string "title"
@@ -36,87 +32,96 @@ ActiveRecord::Schema.define(:version => 0) do
     t.datetime "updated_at"
   end
 
-  create_table "uuid_tag_hierarchies", :id => false, :force => true do |t|
+  create_table "uuid_tag_hierarchies", :id => false do |t|
     t.string "ancestor_id", :null => false
     t.string "descendant_id", :null => false
     t.integer "generations", :null => false
   end
 
-  create_table "destroyed_tags", :force => true do |t|
+  create_table "destroyed_tags" do |t|
     t.string "name"
   end
 
-  force_add_index "tag_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "tag_anc_desc_idx"
-  force_add_index "tag_hierarchies", [:descendant_id], :name => "tag_desc_idx"
+  add_index "tag_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "tag_anc_desc_idx"
+  add_index "tag_hierarchies", [:descendant_id], :name => "tag_desc_idx"
 
-  create_table "users", :force => true do |t|
+  create_table "users" do |t|
     t.string "email"
     t.integer "referrer_id"
     t.datetime "created_at"
     t.datetime "updated_at"
   end
 
-  create_table "contracts", :force => true do |t|
+  add_foreign_key(:users, :users, :column => 'referrer_id')
+
+  create_table "contracts" do |t|
     t.integer "user_id", :null => false
   end
 
-  create_table "referral_hierarchies", :id => false, :force => true do |t|
+  create_table "referral_hierarchies", :id => false do |t|
     t.integer "ancestor_id", :null => false
     t.integer "descendant_id", :null => false
     t.integer "generations", :null => false
   end
 
-  force_add_index "referral_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "ref_anc_desc_idx"
-  force_add_index "referral_hierarchies", [:descendant_id], :name => "ref_desc_idx"
+  add_index "referral_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "ref_anc_desc_idx"
+  add_index "referral_hierarchies", [:descendant_id], :name => "ref_desc_idx"
 
-  create_table "labels", :force => true do |t|
+  create_table "labels" do |t|
     t.string "name"
     t.string "type"
     t.integer "sort_order"
     t.integer "mother_id"
   end
 
-  create_table "label_hierarchies", :id => false, :force => true do |t|
+  add_foreign_key(:labels, :labels, :column => 'mother_id')
+
+  create_table "label_hierarchies", :id => false do |t|
     t.integer "ancestor_id", :null => false
     t.integer "descendant_id", :null => false
     t.integer "generations", :null => false
   end
 
-  force_add_index "label_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "lh_anc_desc_idx"
-  force_add_index "label_hierarchies", [:descendant_id], :name => "lh_desc_idx"
+  add_index "label_hierarchies", [:ancestor_id, :descendant_id, :generations], :unique => true, :name => "lh_anc_desc_idx"
+  add_index "label_hierarchies", [:descendant_id], :name => "lh_desc_idx"
 
-  create_table "cuisine_types", :force => true do |t|
+  create_table "cuisine_types" do |t|
     t.string "name"
     t.integer "parent_id"
   end
 
-  create_table "cuisine_type_hierarchies", :id => false, :force => true do |t|
+  create_table "cuisine_type_hierarchies", :id => false do |t|
     t.integer "ancestor_id", :null => false
     t.integer "descendant_id", :null => false
     t.integer "generations", :null => false
   end
 
-  create_table "namespace_types", :force => true do |t|
+  create_table "namespace_types" do |t|
     t.string "name"
     t.integer "parent_id"
   end
 
-  create_table "namespace_type_hierarchies", :id => false, :force => true do |t|
+  create_table "namespace_type_hierarchies", :id => false do |t|
     t.integer "ancestor_id", :null => false
     t.integer "descendant_id", :null => false
     t.integer "generations", :null => false
   end
 
-  create_table "metal", :force => true do |t|
+  create_table "metal" do |t|
     t.integer "parent_id"
     t.string "metal_type"
     t.string "value"
     t.integer "sort_order"
   end
 
-  create_table "metal_hierarchies", :id => false, :force => true do |t|
+  add_foreign_key(:metal, :metal, :column => 'parent_id')
+
+  create_table "metal_hierarchies", :id => false do |t|
     t.integer "ancestor_id", :null => false
     t.integer "descendant_id", :null => false
     t.integer "generations", :null => false
   end
+
+  add_foreign_key(:metal_hierarchies, :metal, :column => 'ancestor_id')
+  add_foreign_key(:metal_hierarchies, :metal, :column => 'descendant_id')
 end

data/spec/label_spec.rb

@@ -1,10 +1,5 @@
 require 'spec_helper'
 
-def delete_all_labels
-  LabelHierarchy.delete_all
-  Label.delete_all
-end
-
 def create_label_tree
   @d1 = Label.find_or_create_by_path %w(a1 b1 c1 d1)
   @c1 = @d1.parent
@@ -19,7 +14,7 @@ def create_label_tree
   Label.update_all("sort_order = id")
 end
 
-def create_preorder_tree(suffix = "")
+def create_preorder_tree(suffix = "", &block)
   %w(
     a/l/n/r
     a/l/n/q
@@ -34,10 +29,12 @@ def create_preorder_tree(suffix = "")
 
   Label.roots.each_with_index do |root, root_idx|
     root.order_value = root_idx
+    yield(root) if block_given?
     root.save!
     root.self_and_descendants.each do |ea|
       ea.children.to_a.sort_by(&:name).each_with_index do |ea, idx|
         ea.order_value = idx
+        yield(ea) if block_given?
         ea.save!
       end
     end
@@ -59,9 +56,6 @@ describe Label do
   end
 
   context "roots" do
-    before :each do
-      delete_all_labels
-    end
     it "sorts alphabetically" do
       expected = (0..10).to_a
       expected.shuffle.each do |ea|
@@ -119,27 +113,29 @@ describe Label do
   end
 
   context "Mixed class tree" do
-    it "should support mixed type ancestors" do
-      [Label, DateLabel, DirectoryLabel, EventLabel].permutation do |classes|
-        delete_all_labels
-        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.to_a.should =~ [i]
-        while (!instances.empty?) do
-          child = instances.shift
-          i.children.to_a.should =~ [child]
-          i = child
+    context "preorder tree" do
+      before do
+        classes = [Label, DateLabel, DirectoryLabel, EventLabel]
+        create_preorder_tree do |ea|
+          ea.type = classes[ea.sort_order % 4].to_s
         end
       end
+      it "finds roots with specific classes" do
+        Label.roots.should == Label.where(:name => 'a').to_a
+        DirectoryLabel.roots.should be_empty
+        EventLabel.roots.should be_empty
+      end
+
+      it "all is limited to subclasses" do
+        DateLabel.all.map(&:name).should =~ %w(f h l n p)
+        DirectoryLabel.all.map(&:name).should =~ %w(g q)
+        EventLabel.all.map(&:name).should == %w(r)
+      end
+
+      it "returns descendents regardless of subclass" do
+        Label.root.descendants.map{|ea|ea.class.to_s}.uniq.should =~
+          %w(Label DateLabel DirectoryLabel EventLabel)
+      end
     end
 
     it "supports children << and add_child" do
@@ -160,8 +156,7 @@ describe Label do
   end
 
   context "find_all_by_generation" do
-    before :all do
-      delete_all_labels
+    before :each do
       create_label_tree
     end
 
@@ -201,8 +196,7 @@ describe Label do
   end
 
   context "loading through self_and_ scopes" do
-    before :all do
-      delete_all_labels
+    before :each do
       create_label_tree
     end
 
@@ -286,10 +280,6 @@ describe Label do
   end
 
   context "#add_sibling" do
-    before :each do
-      Label.delete_all
-    end
-
     it "should move a node before another node which has an uninitialized sort_order" do
       f = Label.find_or_create_by_path %w(a b c d e fa)
       f0 = f.prepend_sibling(Label.new(:name => "fb")) # < not alpha sort, so name shouldn't matter
@@ -325,7 +315,6 @@ describe Label do
 
   context "destructive reordering" do
     before :each do
-      Label.delete_all
       # to make sure sort_order isn't affected by additional nodes:
       create_preorder_tree
       @root = Label.create(:name => "root")
@@ -359,7 +348,6 @@ describe Label do
 
   context "preorder" do
     it "returns descendants in proper order" do
-      delete_all_labels
       create_preorder_tree
       a = Label.root
       a.name.should == "a"

data/spec/parallel_prepend_sibling_spec.rb

@@ -4,8 +4,6 @@ require 'securerandom'
 describe "threadhot" do
 
   before :each do
-    LabelHierarchy.delete_all
-    Label.delete_all
     @iterations = 5
     @workers = 8
   end

data/spec/parallel_spec.rb

@@ -7,41 +7,62 @@ parallelism_is_broken = begin
     ENV["DB"] =~ /sqlite/
 end
 
+class DbThread
+  def initialize(&block)
+    @thread = Thread.new do
+      ActiveRecord::Base.connection_pool.with_connection(&block)
+    end
+  end
+
+  def join
+    @thread.join
+  end
+end
+
 describe "threadhot" do
 
   before :each do
-    ActiveRecord::Base.connection.reconnect!
-    TagHierarchy.delete_all
-    Tag.delete_all
     @parent = nil
-    # These values seem to allow Travis to reliably pass:
-    @iterations = 5
-    @workers = 6
-    @time_between_runs = 3
+    @iterations = 3
+    @workers = 10
+    @min_sleep_time = 0.3
+    @lock = Mutex.new
+    @wake_times = []
+    DatabaseCleaner.clean
+  end
+
+  after :each do
+    DatabaseCleaner.clean
   end
 
-  def find_or_create_at_even_second(run_at)
-    sleep(run_at - Time.now.to_f)
-    ActiveRecord::Base.connection.reconnect!
-    (@parent || Tag).find_or_create_by_path([run_at.to_s, :a, :b, :c])
+  def find_or_create_at_same_time(name)
+    @lock.synchronize { @wake_times << Time.now.to_f + @min_sleep_time }
+    while @wake_times.size < @workers
+      sleep(0.1)
+    end
+    max_wait_time = @lock.synchronize { @wake_times.max }
+    sleep_time = max_wait_time - Time.now.to_f
+    $stderr.puts "sleeping for #{sleep_time}"
+    sleep(sleep_time)
+    (@parent || Tag).find_or_create_by_path([name.to_s, :a, :b, :c])
   end
 
   def run_workers
-    expected_thread_setup_time = 4
-    start_time = Time.now.to_i + expected_thread_setup_time
-    @times = @iterations.times.collect { |ea| start_time + (ea * @time_between_runs) }
-    @names = @times.collect { |ea| ea.to_s }
-    @threads = @workers.times.collect do
-      Thread.new do
-        @times.each { |ea| find_or_create_at_even_second(ea) }
+    @names = []
+    @iterations.times.each do |iter|
+      name = "iteration ##{iter}"
+      @names << name
+      threads = @workers.times.map do
+        DbThread.new { find_or_create_at_same_time(name) }
       end
+      threads.each { |ea| ea.join }
+      @wake_times.clear
     end
-    @threads.each { |ea| ea.join }
   end
 
   it "class method will not create dupes" do
     run_workers
-    Tag.roots.collect { |ea| ea.name.to_i }.should =~ @times
+    Tag.roots.collect { |ea| ea.name }.should =~ @names
     # No dupe children:
     %w(a b c).each do |ea|
       Tag.where(:name => ea).size.should == @iterations
@@ -51,7 +72,7 @@ describe "threadhot" do
   it "instance method will not create dupes" do
     @parent = Tag.create!(:name => "root")
     run_workers
-    @parent.reload.children.collect { |ea| ea.name.to_i }.should =~ @times
+    @parent.reload.children.collect { |ea| ea.name }.should =~ @names
     Tag.where(:name => @names).size.should == @iterations
     %w(a b c).each do |ea|
       Tag.where(:name => ea).size.should == @iterations
@@ -65,7 +86,7 @@ describe "threadhot" do
     Tag.where(:name => @names).size.should > @iterations
   end
 
-  it "fails to deadlock from parallel sibling churn" do
+  it 'fails to deadlock from parallel sibling churn' do
     # target should be non-trivially long to maximize time spent in hierarchy maintenance
     target = Tag.find_or_create_by_path(('a'..'z').to_a + ('A'..'Z').to_a)
     expected_children = (1..100).to_a.map { |ea| "root ##{ea}" }
@@ -74,29 +95,30 @@ describe "threadhot" do
     children_to_delete = []
     deleted_children = []
     creator_threads = @workers.times.map do
-      Thread.new do
-        ActiveRecord::Base.connection.reconnect!
-        begin
+      DbThread.new do
+        while children_to_add.present?
           name = children_to_add.shift
           unless name.nil?
-            target.find_or_create_by_path(name)
+            Tag.transaction { target.find_or_create_by_path(name) }
             children_to_delete << name
             added_children << name
           end
-        end while !children_to_add.empty?
+        end
       end
     end
     run_destruction = true
     destroyer_threads = @workers.times.map do
-      Thread.new do
-        ActiveRecord::Base.connection.reconnect!
+      DbThread.new do
         begin
-          victim = children_to_delete.shift
-          if victim
-            target.children.where(:name => victim).first.destroy
-            deleted_children << victim
+          victim_name = children_to_delete.shift
+          if victim_name
+            Tag.transaction do
+              victim = target.children.where(:name => victim_name).first
+              victim.destroy
+              deleted_children << victim_name
+            end
           else
-            sleep rand # wait for moar victims
+            sleep rand # wait for more victims
           end
         end while run_destruction || !children_to_delete.empty?
       end
@@ -104,33 +126,19 @@ describe "threadhot" do
     creator_threads.each { |ea| ea.join }
     run_destruction = false
     destroyer_threads.each { |ea| ea.join }
-
     added_children.should =~ expected_children
     deleted_children.should =~ expected_children
   end
 
-  # Oh, yeah, I'm totes monkey patching in a bad shuffle. I AM A NAUGHTY MONKAY
-  class Array
-    def bad_shuffle!(shuffle_count = nil)
-      shuffle_count ||= size / 10
-      pairs = Hash[*(0..(size)).to_a.shuffle.first(shuffle_count)]
-      pairs.each do |from, to|
-        self[from], self[to] = self[to], self[from]
-      end
-      self
-    end
-  end
-
   it "fails to deadlock while simultaneously deleting items from the same hierarchy" do
     target = User.find_or_create_by_path((1..200).to_a.map { |ea| ea.to_s })
-    nodes_to_delete = target.self_and_ancestors.to_a.bad_shuffle!
+    to_delete = target.self_and_ancestors.to_a.shuffle.map(&:email)
     destroyer_threads = @workers.times.map do
-      Thread.new do
-        ActiveRecord::Base.connection.reconnect!
-        begin
-          victim = nodes_to_delete.shift
-          victim.destroy if victim
-        end while !nodes_to_delete.empty?
+      DbThread.new do
+        until to_delete.empty?
+          email = to_delete.shift
+          User.transaction { User.where(:email => email).first.destroy } if email
+        end
       end
     end
     destroyer_threads.each { |ea| ea.join }

data/spec/spec_helper.rb

@@ -5,17 +5,17 @@ require 'rubygems'
 ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
 require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
 require 'rspec'
-require 'rails'
 require 'active_record'
-require 'active_record/fixtures'
-require 'rspec/rails/adapters'
-require 'rspec/rails/fixture_support'
+require 'foreigner'
+require 'database_cleaner'
 require 'closure_tree'
 require 'tmpdir'
 
-#log = Logger.new(STDOUT)
-#log.sev_threshold = Logger::DEBUG
-#ActiveRecord::Base.logger = log
+if ENV['STDOUT_LOGGING']
+  log = Logger.new(STDOUT)
+  log.sev_threshold = Logger::DEBUG
+  ActiveRecord::Base.logger = log
+end
 
 require 'yaml'
 require 'erb'
@@ -29,11 +29,30 @@ if ENV['ATTR_ACCESSIBLE'] == '1'
 end
 
 ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result)
+
+def recreate_db
+  db_name = ActiveRecord::Base.configurations[ENV["DB"]]["database"]
+  case ENV['DB'] || 'mysql'
+    when 'sqlite'
+      File.delete 'spec/sqlite3.db' if File.exist? 'spec/sqlite3.db'
+    when 'postgresql'
+      `psql -c 'DROP DATABASE #{db_name}' -U postgres`
+      `psql -c 'CREATE DATABASE #{db_name}' -U postgres`
+    when 'mysql'
+      `mysql -e 'DROP DATABASE IF EXISTS #{db_name}'`
+      `mysql -e 'CREATE DATABASE #{db_name}'`
+  end
+  ActiveRecord::Base.connection.reconnect!
+end
+
 ActiveRecord::Base.establish_connection(ENV["DB"])
+
 ActiveRecord::Migration.verbose = false
 if ENV['NONUKES']
   puts 'skipping database creation'
 else
+  Foreigner.load
+  recreate_db
   require 'db/schema'
 end
 require 'support/models'
@@ -65,12 +84,14 @@ end
 
 Thread.abort_on_exception = true
 
+DatabaseCleaner.strategy = :truncation
+
 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
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
   config.after(:each) do
+    DatabaseCleaner.clean
     DB_QUERIES.clear
   end
   config.before(:all) do

data/spec/support/models.rb

@@ -95,7 +95,7 @@ module Namespace
 end
 
 class Metal < ActiveRecord::Base
-  self.table_name = 'metal'
+  self.table_name = "#{table_name_prefix}metal#{table_name_suffix}"
   acts_as_tree :order => 'sort_order'
   self.inheritance_column = 'metal_type'
 end

data/spec/tag_examples.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-shared_examples_for "Tag (without fixtures)" do
+shared_examples_for Tag do
 
   let (:tag_class) { described_class }
   let (:tag_hierarchy_class) { described_class.hierarchy_class }
@@ -26,27 +26,71 @@ shared_examples_for "Tag (without fixtures)" do
   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
+
+      it "#find_or_create_by_path" do
+        a = tag_class.create!(:name => 'a')
+        a.find_or_create_by_path(%w{b c}).ancestry_path.should == %w{a b c}
+      end
     end
 
     context "with 1 tag" do
+      before do
+        @tag = tag_class.create!(:name => "tag")
+      end
+
+      it "should be a leaf" do
+        @tag.leaf?.should be_true
+      end
+
+      it "should be a root" do
+        @tag.root?.should be_true
+      end
+
+      it 'has no parent' do
+        @tag.parent.should be_nil
+      end
+
       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]
+        tag_class.all.should == [@tag]
+        tag_class.roots.should == [@tag]
+        tag_class.leaves.should == [@tag]
+      end
+
+      context "with child" do
+        before do
+          @child = tag_class.create!(:name => 'tag 2')
+        end
+
+        def assert_roots_and_leaves
+          @tag.root?.should be_true
+          @tag.leaf?.should be_false
+
+          @child.root?.should be_false
+          @child.leaf?.should be_true
+        end
+
+        def assert_parent_and_children
+          @child.reload.parent.should == @tag
+          @tag.reload.children.to_a.should == [@child]
+        end
+
+        it "adds children through add_child" do
+          @tag.add_child @child
+          assert_roots_and_leaves
+          assert_parent_and_children
+        end
+
+        it "adds children through collection" do
+          @tag.children << @child
+          assert_roots_and_leaves
+          assert_parent_and_children
+        end
       end
     end
 
@@ -62,6 +106,7 @@ shared_examples_for "Tag (without fixtures)" do
       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
@@ -104,6 +149,28 @@ shared_examples_for "Tag (without fixtures)" do
         @mid.children << t
         t.self_and_ancestors.to_a.should == [t, @mid, @root]
       end
+
+      it 'prevents ancestor loops' do
+        @leaf.add_child @root
+        @root.should_not be_valid
+        @root.reload.descendants.should include(@leaf)
+      end
+
+      it 'moves non-leaves' do
+        new_root = tag_class.create! :name => "new_root"
+        new_root.children << @mid
+        @root.reload.descendants.should be_empty
+        new_root.descendants.should == [@mid, @leaf]
+        @leaf.reload.ancestry_path.should == %w{new_root mid leaf}
+      end
+
+      it 'moves leaves' do
+        new_root = tag_class.create! :name => "new_root"
+        new_root.children << @leaf
+        new_root.descendants.should == [@leaf]
+        @root.reload.descendants.should == [@mid]
+        @leaf.reload.ancestry_path.should == %w{new_root leaf}
+      end
     end
 
     context "3 tag explicit_create db" do
@@ -197,13 +264,20 @@ shared_examples_for "Tag (without fixtures)" 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(a1 b1 c1c)
+        tag_class.find_or_create_by_path %w(a1 b1b)
         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
+        @a1, @a2, @a3, @b1, @b1b, @b2, @c1a, @c1b, @c1c = tag_class.
+          where(:name => %w(a1 a2 a3 b1 b1b b2 c1a c1b c1c)).
+          reorder(:name).to_a
         @expected_roots = [@a1, @a2, @a3]
-        @expected_leaves = [@c1a, @c1b, @b2, @a3]
+        @expected_leaves = [@c1a, @c1b, @c1c, @b1b, @b2, @a3]
+        @expected_siblings = [[@a1, @a2, @a3], [@b1, @b1b], [@c1a, @c1b, @c1c]]
+        @expected_only_children = tag_class.all - @expected_siblings.flatten
       end
+
       it 'should find global roots' do
         tag_class.roots.to_a.should =~ @expected_roots
       end
@@ -222,8 +296,37 @@ shared_examples_for "Tag (without fixtures)" do
       it 'should assemble global leaves' do
         tag_class.leaves.to_a.should =~ @expected_leaves
       end
+      it 'assembles siblings properly' do
+        @expected_siblings.each do |siblings|
+          siblings.each do |ea|
+            ea.self_and_siblings.to_a.should =~ siblings
+            ea.siblings.to_a.should =~ siblings - [ea]
+          end
+        end
+        @expected_only_children.each do |ea|
+          ea.siblings.should == []
+        end
+      end
+      it 'assembles before_siblings' do
+        @expected_siblings.each do |siblings|
+          (siblings.size - 1).times do |i|
+            target = siblings[i]
+            expected_before = siblings.first(i)
+            target.siblings_before.to_a.should == expected_before
+          end
+        end
+      end
+      it 'assembles after_siblings' do
+        @expected_siblings.each do |siblings|
+          (siblings.size - 1).times do |i|
+            target = siblings[i]
+            expected_after = siblings.last(siblings.size - 1 - i)
+            target.siblings_after.to_a.should == expected_after
+          end
+        end
+      end
       it 'should assemble instance leaves' do
-        {@a1 => [@c1a, @c1b], @b1 => [@c1a, @c1b], @a2 => [@b2]}.each do |node, leaves|
+        {@a1 => [@b1b, @c1a, @c1b, @c1c], @b1 => [@c1a, @c1b, @c1c], @a2 => [@b2]}.each do |node, leaves|
           node.leaves.to_a.should == leaves
         end
         @expected_leaves.each { |ea| ea.leaves.to_a.should == [ea] }
@@ -231,16 +334,29 @@ shared_examples_for "Tag (without fixtures)" do
       it 'should return leaf? for leaves' do
         @expected_leaves.each { |ea| ea.should be_leaf }
       end
+
+      it 'can move roots' do
+        @c1a.children << @a2
+        @b2.reload.children << @a3
+        @a3.reload.ancestry_path.should ==%w(a1 b1 c1a a2 b2 a3)
+      end
+
+      it 'cascade-deletes from roots' do
+        victim_names = @a1.self_and_descendants.map(&:name)
+        survivor_names = tag_class.all.map(&:name) - victim_names
+        @a1.destroy
+        tag_class.all.map(&:name).should == survivor_names
+      end
     end
 
     context 'with_ancestor' do
       it 'works with no rows' do
-        tag_class.with_ancestor().to_a.should be_empty
+        tag_class.with_ancestor.to_a.should be_empty
       end
       it 'finds only children' do
         c = tag_class.find_or_create_by_path %w(A B C)
         a, b = c.parent.parent, c.parent
-        e = tag_class.find_or_create_by_path %w(D E)
+        spurious_tags = tag_class.find_or_create_by_path %w(D E)
         tag_class.with_ancestor(a).to_a.should == [b, c]
       end
       it 'limits subsequent where clauses' do
@@ -268,6 +384,11 @@ shared_examples_for "Tag (without fixtures)" do
         @child.ancestry_path(:title).should == %w{Nonnie Mom Kid}
       end
 
+      it 'assembles ancestors' do
+        @child.ancestors.should == [@parent, @grandparent]
+        @child.self_and_ancestors.should == [@child, @parent, @grandparent]
+      end
+
       it "should find by path" do
         # class method:
         tag_class.find_by_path(%w{grandparent parent child}).should == @child
@@ -311,17 +432,12 @@ shared_examples_for "Tag (without fixtures)" do
         tag_class.find_by_path(%w{grandparent parent missing child}).should be_nil
       end
 
-      it "should find or create by path" do
-        # class method:
+      it ".find_or_create_by_path" do
         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
 
       it "should respect attribute hashes with both selection and creation" do

data/spec/tag_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 require 'tag_examples'
-require 'tag_fixture_examples'
 
 describe Tag do
-  it_behaves_like 'Tag (without fixtures)'
-  it_behaves_like 'Tag (with fixtures)'
+  it_behaves_like Tag
 end

data/spec/user_spec.rb

@@ -2,11 +2,6 @@ require 'spec_helper'
 
 describe "empty db" do
 
-  before :each do
-    ReferralHierarchy.delete_all
-    User.delete_all
-  end
-
   context "empty db" do
     it "should return no entities" do
       User.roots.should be_empty

data/spec/uuid_tag_spec.rb

@@ -2,5 +2,5 @@ require 'spec_helper'
 require 'tag_examples'
 
 describe UUIDTag do
-  it_behaves_like "Tag (without fixtures)"
+  it_behaves_like Tag
 end unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 4.2.9
+  version: 4.3.0
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-10 00:00:00.000000000 Z
+date: 2013-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -178,6 +178,34 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: foreigner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Easily and efficiently make your ActiveRecord model support hierarchies
 email:
 - matthew-github@mceachen.org
@@ -214,7 +242,6 @@ files:
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/tag_examples.rb
-- spec/tag_fixture_examples.rb
 - spec/tag_spec.rb
 - spec/user_spec.rb
 - spec/uuid_tag_spec.rb
@@ -238,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.5
+rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
 summary: Easily and efficiently make your ActiveRecord model support hierarchies
@@ -255,7 +282,6 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/tag_examples.rb
-- spec/tag_fixture_examples.rb
 - spec/tag_spec.rb
 - spec/user_spec.rb
 - spec/uuid_tag_spec.rb

data/spec/tag_fixture_examples.rb

@@ -1,136 +0,0 @@
-shared_examples_for 'Tag (with fixtures)' do
-
-  let (:tag_class) { described_class }
-  let (:tag_hierarchy_class) { described_class.hierarchy_class }
-
-  describe 'Tag (with fixtures)' do
-    fixtures :tags
-    before :each do
-      tag_class.rebuild!
-      DestroyedTag.delete_all
-    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 be_true
-        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.reload.ancestry_path.should == %w{roottest1 branch1 leaf1}
-        l2.reload.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 be_true
-        tags(:parent).children.include? tags(:child).should be_true
-        tags(:child).children.should be_empty
-      end
-
-      it 'assembles siblings correctly' do
-        tags(:b1).siblings.to_a.should =~ [tags(:b2)]
-        tags(:a1).siblings.to_a.should =~ (Tag.roots.to_a - [tags(:a1)])
-        tags(:a1).self_and_siblings.to_a.should =~ Tag.roots.to_a
-
-        # must be ordered
-        tags(:indoor).siblings.to_a.should == [tags(:home), tags(:museum), tags(:outdoor), tags(:united_states)]
-        tags(:indoor).self_and_siblings.to_a.should == [tags(:home), tags(:indoor), tags(:museum), tags(:outdoor), tags(:united_states)]
-      end
-
-      it 'assembles siblings before correctly' do
-        tags(:home).siblings_before.to_a.should == []
-        tags(:indoor).siblings_before.to_a.should == [tags(:home)]
-        tags(:outdoor).siblings_before.to_a.should == [tags(:home), tags(:indoor), tags(:museum)]
-        tags(:united_states).siblings_before.to_a.should == [tags(:home), tags(:indoor), tags(:museum), tags(:outdoor)]
-      end
-
-      it 'assembles siblings after correctly' do
-        tags(:indoor).siblings_after.to_a.should == [tags(:museum), tags(:outdoor), tags(:united_states)]
-        tags(:outdoor).siblings_after.to_a.should == [tags(:united_states)]
-        tags(:united_states).siblings_after.to_a.should == []
-      end
-
-      it 'assembles ancestors' do
-        tags(:child).ancestors.should == [tags(:parent), tags(:grandparent)]
-        tags(:child).self_and_ancestors.should == [tags(:child), tags(:parent), tags(:grandparent)]
-      end
-
-      it 'assembles descendants' 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
-
-    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
-end