closure_tree 4.6.3 → 5.0.0

data/lib/closure_tree/support_attributes.rb

@@ -3,15 +3,10 @@ module ClosureTree
   module SupportAttributes
 
     extend Forwardable
-    def_delegators :model_class, :connection, :transaction, :table_name
+    def_delegators :model_class, :connection, :transaction, :table_name, :base_class, :inheritance_column, :column_names
 
-    # This is the "topmost" class. This will only potentially not be ct_class if you are using STI.
-    def base_class
-      options[:base_class]
-    end
-
-    def attribute_names
-      @attribute_names ||= model_class.new.attributes.keys - model_class.protected_attributes.to_a
+    def advisory_lock_name
+      "ClosureTree::#{base_class.name}"
     end
 
     def quoted_table_name

data/lib/closure_tree/support_flags.rb

@@ -27,13 +27,12 @@ module ClosureTree
       model_class != model_class.base_class
     end
 
-    def has_type?
-      attribute_names.include? 'type'
+    def has_inheritance_column?(hash = columns_hash)
+      hash.with_indifferent_access.include?(model_class.inheritance_column)
     end
 
     def has_name?
       model_class.new.attributes.include? options[:name_column]
     end
-
   end
 end

data/lib/closure_tree/version.rb

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

data/spec/db/database.yml

@@ -1,5 +1,5 @@
 common: &common
-  database: closure_tree_test<%= ENV['TRAVIS_JOB_NUMBER'].to_s.gsub(/\W/, '_') %>
+  database: <%= db_name %>
   host: localhost
   pool: 50
   timeout: 5000
@@ -7,8 +7,8 @@ common: &common
   min_messages: ERROR
 
 sqlite:
+  <<: *common
   adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: ':memory:'
 
 postgresql:
   <<: *common

data/spec/db/models.rb

@@ -98,10 +98,16 @@ end
 
 class Metal < ActiveRecord::Base
   self.table_name = "#{table_name_prefix}metal#{table_name_suffix}"
-  acts_as_tree :order => 'sort_order'
+  acts_as_tree order: 'sort_order', name_column: 'value'
   self.inheritance_column = 'metal_type'
 end
 
+class Adamantium < Metal
+end
+
+class Unobtanium < Metal
+end
+
 class MenuItem < ActiveRecord::Base
   acts_as_tree(touch: true, with_advisory_lock: false)
 end

data/spec/db/schema.rb

@@ -111,6 +111,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.integer "parent_id"
     t.string "metal_type"
     t.string "value"
+    t.string "description"
     t.integer "sort_order"
   end
 

data/spec/hierarchy_maintenance_spec.rb

@@ -7,6 +7,7 @@ describe ClosureTree::HierarchyMaintenance do
         Metal.create(:value => "Nitro-#{counter}", parent: Metal.all.sample)
       end
       hierarchy_count = MetalHierarchy.count
+      expect(hierarchy_count).to be > (20*2)-1 # shallowest-possible case, where all children use the first root
       MetalHierarchy.delete_all
       Metal.rebuild!
       expect(MetalHierarchy.count).to eq(hierarchy_count)

data/spec/label_spec.rb

@@ -42,7 +42,6 @@ def create_preorder_tree(suffix = "", &block)
 end
 
 describe Label do
-
   context "destruction" do
     it "properly destroys descendents created with find_or_create_by_path" do
       c = Label.find_or_create_by_path %w(a b c)
@@ -54,10 +53,8 @@ describe Label do
 
     it "properly destroys descendents created with add_child" do
       a = Label.create(name: 'a')
-      b = Label.new(name: 'b')
-      a.add_child b
-      c = Label.new(name: 'c')
-      b.add_child c
+      b = a.add_child Label.new(name: 'b')
+      c = b.add_child Label.new(name: 'c')
       a.destroy
       expect(Label.exists?(a)).to be_falsey
       expect(Label.exists?(b)).to be_falsey
@@ -292,36 +289,51 @@ describe Label do
     end
   end
 
-  it 'behaves like the readme' do
-    root = Label.create(name: 'root')
-    a = root.append_child(Label.new(name: 'a'))
-    b = Label.create(name: 'b')
-    c = Label.create(name: 'c')
-
-    a.append_sibling(b)
-    expect(a.self_and_siblings.collect(&:name)).to eq(%w(a b))
-    expect(root.reload.children.collect(&:name)).to eq(%w(a b))
-    expect(root.children.collect(&:order_value)).to eq([0, 1])
-
-    a.prepend_sibling(b)
-    expect(a.self_and_siblings.collect(&:name)).to eq(%w(b a))
-    expect(root.reload.children.collect(&:name)).to eq(%w(b a))
-    expect(root.children.collect(&:order_value)).to eq([0, 1])
-
-    a.append_sibling(c)
-    expect(a.self_and_siblings.collect(&:name)).to eq(%w(b a c))
-    expect(root.reload.children.collect(&:name)).to eq(%w(b a c))
-    expect(root.children.collect(&:order_value)).to eq([0, 1, 2])
-
-    # We need to reload b because it was updated by a.append_sibling(c)
-    b.reload.append_sibling(c)
-    expect(root.reload.children.collect(&:name)).to eq(%w(b c a))
-    expect(root.children.collect(&:order_value)).to eq([0, 1, 2])
-
-    # We need to reload a because it was updated by b.append_sibling(c)
-    d = a.reload.append_sibling(Label.new(:name => "d"))
-    expect(d.self_and_siblings.collect(&:name)).to eq(%w(b c a d))
-    expect(d.self_and_siblings.collect(&:order_value)).to eq([0, 1, 2, 3])
+  describe 'code in the readme' do
+    it 'creates STI label hierarchies' do
+      child = Label.find_or_create_by_path([
+        {type: 'DateLabel', name: '2014'},
+        {type: 'DateLabel', name: 'August'},
+        {type: 'DateLabel', name: '5'},
+        {type: 'EventLabel', name: 'Visit the Getty Center'}
+      ])
+      expect(child).to be_a(EventLabel)
+      expect(child.name).to eq('Visit the Getty Center')
+      expect(child.ancestors.map(&:name)).to eq(%w(5 August 2014))
+      expect(child.ancestors.map(&:class)).to eq([DateLabel, DateLabel, DateLabel])
+    end
+
+    it 'appends and prepends siblings' do
+      root = Label.create(name: 'root')
+      a = root.append_child(Label.new(name: 'a'))
+      b = Label.create(name: 'b')
+      c = Label.create(name: 'c')
+
+      a.append_sibling(b)
+      expect(a.self_and_siblings.collect(&:name)).to eq(%w(a b))
+      expect(root.reload.children.collect(&:name)).to eq(%w(a b))
+      expect(root.children.collect(&:order_value)).to eq([0, 1])
+
+      a.prepend_sibling(b)
+      expect(a.self_and_siblings.collect(&:name)).to eq(%w(b a))
+      expect(root.reload.children.collect(&:name)).to eq(%w(b a))
+      expect(root.children.collect(&:order_value)).to eq([0, 1])
+
+      a.append_sibling(c)
+      expect(a.self_and_siblings.collect(&:name)).to eq(%w(b a c))
+      expect(root.reload.children.collect(&:name)).to eq(%w(b a c))
+      expect(root.children.collect(&:order_value)).to eq([0, 1, 2])
+
+      # We need to reload b because it was updated by a.append_sibling(c)
+      b.reload.append_sibling(c)
+      expect(root.reload.children.collect(&:name)).to eq(%w(b c a))
+      expect(root.children.collect(&:order_value)).to eq([0, 1, 2])
+
+      # We need to reload a because it was updated by b.append_sibling(c)
+      d = a.reload.append_sibling(Label.new(:name => "d"))
+      expect(d.self_and_siblings.collect(&:name)).to eq(%w(b c a d))
+      expect(d.self_and_siblings.collect(&:order_value)).to eq([0, 1, 2, 3])
+    end
   end
 
   # https://github.com/mceachen/closure_tree/issues/84
@@ -511,5 +523,5 @@ describe Label do
       expected += ('a'..'r').collect { |ea| "#{ea}1" }
       expect(Label.roots_and_descendants_preordered.collect { |ea| ea.name }).to eq(expected)
     end
-  end unless ENV['DB'] == 'sqlite' # sqlite doesn't have a power function.
+  end unless sqlite? # sqlite doesn't have a power function.
 end

data/spec/metal_spec.rb

@@ -1,9 +1,55 @@
 require 'spec_helper'
 
 describe Metal do
-  it "creates" do
-    s = Metal.create(:value => 'System')
-    s.reload
-    expect(s).not_to be_new_record
+  describe '#find_or_create_by_path' do
+    def assert_correctness(grandchild)
+      expect(grandchild).to be_a(Metal)
+      expect(grandchild.description).to eq('slag')
+      child = grandchild.parent
+      expect(child).to be_a(Unobtanium)
+      expect(child.description).to eq('frames')
+      expect(child.value).to eq('child')
+      parent = child.parent
+      expect(parent).to be_a(Adamantium)
+      expect(parent.description).to eq('claws')
+      expect(parent.value).to eq('parent')
+    end
+
+    let(:attr_path) do
+      [
+        {value: 'parent', description: 'claws', metal_type: 'Adamantium'},
+        {value: 'child', description: 'frames', metal_type: 'Unobtanium'},
+        {value: 'grandchild', description: 'slag', metal_type: 'Metal'}
+      ]
+    end
+
+    before do
+      # ensure the correct root is used in find_or_create_by_path:
+      [Metal, Adamantium, Unobtanium].each do |metal|
+        metal.find_or_create_by_path(%w(parent child grandchild))
+      end
+    end if false
+
+    it 'creates children from the proper root' do
+      assert_correctness(Metal.find_or_create_by_path(attr_path))
+    end
+
+    it 'supports STI from the base class' do
+      assert_correctness(Metal.find_or_create_by_path(attr_path))
+    end
+
+    it 'supports STI from a subclass' do
+      parent = Adamantium.create!(value: 'parent', description: 'claws')
+      assert_correctness(parent.find_or_create_by_path(attr_path.last(2)))
+    end
+
+    it 'maintains the current STI subclass if attributes are not specified' do
+      leaf = Unobtanium.find_or_create_by_path(%w(a b c d))
+      expect(leaf).to be_a(Unobtanium)
+      expect(leaf.ancestors.map(&:value)).to eq(%w(c b a))
+      leaf.ancestors.each do |anc|
+        expect(anc).to be_a(Unobtanium)
+      end
+    end
   end
 end

data/spec/parallel_spec.rb

@@ -1,59 +1,75 @@
 require 'spec_helper'
-require 'securerandom'
+
+# We don't need to run the expensive parallel tests for every combination of prefix/suffix.
+# Those affect SQL generation, not parallelism
+def run_parallel_tests?
+  ActiveRecord::Base.table_name_prefix.empty? &&
+    ActiveRecord::Base.table_name_suffix.empty?
+end
+
+def max_threads
+  5
+end
 
 class WorkerBase
-  def initialize(target, run_at, name)
+  extend Forwardable
+  attr_reader :name
+  def_delegators :@thread, :join, :wakeup, :status, :to_s
+
+  def initialize(target, name)
     @target = target
+    @name = name
     @thread = Thread.new do
-      ActiveRecord::Base.connection_pool.with_connection do
-        before_work
-        sleep((run_at - Time.now).to_f)
-        do_work(name)
-      end
+      ActiveRecord::Base.connection_pool.with_connection { before_work } if respond_to? :before_work
+      puts "#{Thread.current} going to sleep..."
+      sleep
+      puts "#{Thread.current} woke up..."
+      ActiveRecord::Base.connection_pool.with_connection { work }
+      puts "#{Thread.current} done..."
     end
   end
-
-  def before_work
-  end
-
-  def work(name)
-    raise
-  end
-
-  def join
-    @thread.join
-  end
 end
 
 class FindOrCreateWorker < WorkerBase
-  def do_work(name)
-    (@target || Tag).find_or_create_by_path([name.to_s, :a, :b, :c])
+  def work
+    path = [name, :a, :b, :c]
+    puts "#{Thread.current} making #{path}..."
+    t = (@target || Tag).find_or_create_by_path(path)
+    puts "#{Thread.current} made #{t.id}, #{t.ancestry_path}"
   end
 end
 
-describe 'Concurrent creation', if: support_concurrency do
-
+describe 'Concurrent creation' do
   before :each do
     @target = nil
     @iterations = 5
-    @threads = 10
   end
 
   def run_workers(worker_class = FindOrCreateWorker)
-    all_workers = []
     @names = @iterations.times.map { |iter| "iteration ##{iter}" }
     @names.each do |name|
-      wake_time = 1.second.from_now
-      workers = @threads.times.map do
-        worker_class.new(@target, wake_time, name)
+      workers = max_threads.times.map { worker_class.new(@target, name) }
+      # Wait for all the threads to get ready:
+      while true
+        unready_workers = workers.select { |ea| ea.status != 'sleep' }
+        if unready_workers.empty?
+          break
+        else
+          puts "Not ready to wakeup: #{unready_workers.map { |ea| [ea.to_s, ea.status] }}"
+          sleep(0.1)
+        end
       end
+      sleep(0.25)
+      # OK, GO!
+      puts 'Calling .wakeup on all workers...'
+      workers.each(&:wakeup)
+      sleep(0.25)
+      # Then wait for them to finish:
+      puts 'Calling .join on all workers...'
       workers.each(&:join)
-      all_workers += workers
-      puts name
     end
     # Ensure we're still connected:
     ActiveRecord::Base.connection_pool.connection
-    all_workers
   end
 
   it 'will not create dupes from class methods' do
@@ -79,8 +95,9 @@ describe 'Concurrent creation', if: support_concurrency do
     # disable with_advisory_lock:
     allow(Tag).to receive(:with_advisory_lock) { |_lock_name, &block| block.call }
     run_workers
+    # duplication from at least one iteration:
     expect(Tag.where(name: @names).size).to be > @iterations
-  end
+  end unless sqlite? # sqlite throws errors from concurrent access
 
   class SiblingPrependerWorker < WorkerBase
     def before_work
@@ -88,11 +105,12 @@ describe 'Concurrent creation', if: support_concurrency do
       @sibling = Label.new(name: SecureRandom.hex(10))
     end
 
-    def do_work(name)
+    def work
       @target.prepend_sibling @sibling
     end
   end
 
+  # TODO: this test should be rewritten to be proper producer-consumer code
   xit '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)
@@ -102,7 +120,7 @@ describe 'Concurrent creation', if: support_concurrency do
     children_to_delete = []
     deleted_children = []
     creator_threads = @workers.times.map do
-      DbThread.new do
+      Thread.new do
         while children_to_add.present?
           name = children_to_add.shift
           unless name.nil?
@@ -115,7 +133,7 @@ describe 'Concurrent creation', if: support_concurrency do
     end
     run_destruction = true
     destroyer_threads = @workers.times.map do
-      DbThread.new do
+      Thread.new do
         begin
           victim_name = children_to_delete.shift
           if victim_name
@@ -130,27 +148,26 @@ describe 'Concurrent creation', if: support_concurrency do
         end while run_destruction || !children_to_delete.empty?
       end
     end
-    creator_threads.each { |ea| ea.join }
-    run_destruction = false
-    destroyer_threads.each { |ea| ea.join }
+    creator_threads.each(&:join)
+    destroyer_threads.each(&:join)
     expect(added_children).to match(expected_children)
     expect(deleted_children).to match(expected_children)
   end
 
-  xit 'fails to deadlock while simultaneously deleting items from the same hierarchy' do
+  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 })
-    to_delete = target.self_and_ancestors.to_a.shuffle.map(&:email)
-    destroyer_threads = @workers.times.map do
-      DbThread.new do
-        until to_delete.empty?
-          email = to_delete.shift
-          User.transaction { User.where(email: email).first.destroy } if email
+    emails = target.self_and_ancestors.to_a.map(&:email).shuffle
+    Parallel.map(emails, :in_threads => max_threads) do |email|
+      ActiveRecord::Base.connection_pool.with_connection do
+        User.transaction do
+          puts "Destroying #{email}..."
+          User.where(email: email).destroy_all
         end
       end
     end
-    destroyer_threads.each { |ea| ea.join }
+    User.connection.reconnect!
     expect(User.all).to be_empty
-  end
+  end unless sqlite? # sqlite throws errors from concurrent access
 
   class SiblingPrependerWorker < WorkerBase
     def before_work
@@ -158,7 +175,7 @@ describe 'Concurrent creation', if: support_concurrency do
       @sibling = Label.new(name: SecureRandom.hex(10))
     end
 
-    def do_work(name)
+    def work
       @target.prepend_sibling @sibling
     end
   end
@@ -172,6 +189,6 @@ describe 'Concurrent creation', if: support_concurrency do
 
     # The only non-root node should be "root":
     expect(Label.all.select { |ea| ea.root? }).to eq([@target.parent])
-  end
+  end unless sqlite? # sqlite throws errors from concurrent access
 
-end
+end if run_parallel_tests?