closure_tree 3.6.9 → 3.7.0

data/README.md

@@ -362,16 +362,47 @@ No. This gem's API is based on the assumption that each node has either 0 or 1 p
 The underlying closure tree structure will support multiple parents, but there would be many
 breaking-API changes to support it. I'm open to suggestions and pull requests.
 
+### How do I use this with test fixtures?
+
+Test fixtures aren't going to be running your ```after_save``` hooks after inserting all your
+fixture data, so you need to call ```.rebuild!``` before your test runs. There's an example in
+the spec ```tag_spec.rb```:
+
+```ruby
+  describe "Tag with fixtures" do
+    fixtures :tags
+    before :each do
+      Tag.rebuild! # <- required if you use fixtures
+    end
+```
+
+**However, if you're just starting with Rails, may I humbly suggest you adopt a factory library**,
+rather than using fixtures? [Lots of people have written about this already](https://www.google.com/search?q=fixtures+versus+factories).
+
+
 ## Testing
 
 Closure tree is [tested under every combination](http://travis-ci.org/#!/mceachen/closure_tree) of
 
 * Ruby 1.8.7 and Ruby 1.9.3
 * The latest Rails 3.0, 3.1, and 3.2 branches, and
-* MySQL, PostgreSQL, & SQLite.
+* MySQL and PostgreSQL. SQLite works in a single-threaded environment.
+
+Assuming you're using [rbenv](https://github.com/sstephenson/rbenv), you can use ```tests.sh``` to
+run the test matrix locally.
+
+Parallelism is not tested with Rails 3.0.x nor 3.1.x due to this
+[known issue](https://github.com/rails/rails/issues/7538).
 
 ## Change log
 
+### 3.7.0
+
+**Thread safety!**
+* [Advisory locks](https://github.com/mceachen/with_advisory_lock) were
+  integrated with the class-level ```find_or_create_by_path``` and ```rebuild!```.
+* Pessimistic locking is used by the instance-level ```find_or_create_by_path```.
+
 ### 3.6.9
 
 * [Don Morrison](https://github.com/elskwid) massaged the [#hash_tree](#nested-hashes) query to

data/lib/closure_tree.rb

@@ -1,3 +1,6 @@
+require 'active_support'
 require 'closure_tree/acts_as_tree'
 
-ActiveRecord::Base.send :extend, ClosureTree::ActsAsTree
+ActiveSupport.on_load :active_record do
+  ActiveRecord::Base.send :extend, ClosureTree::ActsAsTree
+end

data/lib/closure_tree/acts_as_tree.rb

@@ -209,38 +209,38 @@ module ClosureTree
       path = path.is_a?(Enumerable) ? path.dup : [path]
       node = self
       while !path.empty? && node
-        node = node.children.send("find_by_#{name_column}", path.shift)
+        node = node.children.where(name_sym => path.shift).first
       end
       node
     end
 
     # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
     def find_or_create_by_path(path, attributes = {})
-      path = path.is_a?(Enumerable) ? path.dup : [path]
-      node = self
-      attrs = {}
-      attrs[:type] = self.type if ct_subclass? && ct_has_type?
-      path.each do |name|
-        attrs[name_sym] = name
-        child = node.children.where(attrs).first
-        unless child
+      subpath = path.is_a?(Enumerable) ? path.dup : [path]
+      child_name = subpath.shift
+      return self unless child_name
+      child = transaction do
+        lock!
+        attrs = {name_sym => child_name}
+        attrs[:type] = self.type if ct_subclass? && ct_has_type?
+        self.children.where(attrs).first || begin
           child = self.class.new(attributes.merge(attrs))
-          node.children << child
+          self.children << child
+          child
         end
-        node = child
       end
-      node
+      child.find_or_create_by_path(subpath, attributes)
     end
 
     def find_all_by_generation(generation_level)
       s = ct_base_class.joins(<<-SQL)
-          INNER JOIN (
-            SELECT descendant_id
-            FROM #{quoted_hierarchy_table_name}
-            WHERE ancestor_id = #{self.id}
-            GROUP BY 1
-            HAVING MAX(#{quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
-          ) AS descendants ON (#{quoted_table_name}.#{ct_base_class.primary_key} = descendants.descendant_id)
+        INNER JOIN (
+          SELECT descendant_id
+          FROM #{quoted_hierarchy_table_name}
+          WHERE ancestor_id = #{self.id}
+          GROUP BY 1
+          HAVING MAX(#{quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
+        ) AS descendants ON (#{quoted_table_name}.#{ct_base_class.primary_key} = descendants.descendant_id)
       SQL
       order_option ? s.order(order_option) : s
     end
@@ -347,27 +347,35 @@ module ClosureTree
       # Rebuilds the hierarchy table based on the parent_id column in the database.
       # Note that the hierarchy table will be truncated.
       def rebuild!
-        hierarchy_class.delete_all # not destroy_all -- we just want a simple truncate.
-        roots.each { |n| n.send(:rebuild!) } # roots just uses the parent_id column, so this is safe.
+        with_advisory_lock("closure_tree.#{ct_class}.rebuild") do
+          transaction do
+            hierarchy_class.delete_all # not destroy_all -- we just want a simple truncate.
+            roots.each { |n| n.send(:rebuild!) } # roots just uses the parent_id column, so this is safe.
+          end
+        end
         nil
       end
 
       # Find the node whose +ancestry_path+ is +path+
       def find_by_path(path)
-        root = roots.send("find_by_#{name_column}", path.shift)
-        root.try(:find_by_path, path)
+        subpath = path.dup
+        root = roots.where(name_sym => subpath.shift).first
+        root.find_by_path(subpath) if root
       end
 
       # Find or create nodes such that the +ancestry_path+ is +path+
       def find_or_create_by_path(path, attributes = {})
-        name = path.shift
-        # shenanigans because find_or_create can't infer we want the same class as this:
-        # Note that roots will already be constrained to this subclass (in the case of polymorphism):
-        root = roots.send("find_by_#{name_column}", name)
-        if root.nil?
-          root = create!(attributes.merge(name_sym => name))
+        subpath = path.dup
+        root_name = subpath.shift
+        root = with_advisory_lock("closure_tree.#{ct_class}.find_or_create(#{root_name})") do
+          transaction do
+            # shenanigans because find_or_create can't infer we want the same class as this:
+            # Note that roots will already be constrained to this subclass (in the case of polymorphism):
+            roots.where(name_sym => root_name).first ||
+              create!(attributes.merge(name_sym => root_name))
+          end
         end
-        root.find_or_create_by_path(path, attributes)
+        root.find_or_create_by_path(subpath, attributes)
       end
 
       def hash_tree_scope(limit_depth = nil)

data/lib/closure_tree/version.rb

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

data/spec/db/database.yml

@@ -1,16 +1,19 @@
 sqlite3:
   adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: closure_tree.sqlite3.db
-sqlite3mem:
-  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: ":memory:"
-postgresql:
+  database: spec/sqlite3.db
+  pool: 50
+  timeout: 5000
+
+pg:
   adapter: postgresql
   username: postgres
   database: closure_tree_test
   min_messages: ERROR
+  pool: 50
+
 mysql:
   adapter: mysql2
   host: localhost
   username: root
   database: closure_tree_test
+  pool: 50

data/spec/parallel_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe "threadhot" do
+
+  before :each do
+    TagHierarchy.delete_all
+    Tag.delete_all
+    @iterations = 5
+    @workers = 8
+    @parent = nil
+  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].compact)
+  end
+
+  def run_workers
+    start_time = Time.now.to_i + 2
+    @times = @iterations.times.collect { |ea| start_time + (ea * 2) }
+    @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) }
+      end
+    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
+    # No dupe children:
+    %w(a b c).each do |ea|
+      Tag.find_all_by_name(ea).size.should == @iterations
+    end
+  end
+
+  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
+    Tag.find_all_by_name(@names).size.should == @iterations
+    %w(a b c).each do |ea|
+      Tag.find_all_by_name(ea).size.should == @iterations
+    end
+  end
+
+  it "creates dupe roots without advisory locks" 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
+  end
+
+# SQLite doesn't like parallelism, and Rails 3.0 and 3.1 have known threading issues. SKIP.
+end if ((ENV["DB"] != "sqlite3") && (ActiveRecord::VERSION::STRING =~ /^3.2/))

data/spec/spec_helper.rb

@@ -11,8 +11,9 @@ require 'active_support'
 require 'active_model'
 require 'active_record'
 require 'action_controller' # rspec-rails needs this :(
-
+require 'with_advisory_lock'
 require 'closure_tree'
+require 'tmpdir'
 
 #log = Logger.new(STDOUT)
 #log.sev_threshold = Logger::DEBUG
@@ -20,7 +21,7 @@ require 'closure_tree'
 
 require 'yaml'
 require 'erb'
-ENV["DB"] ||= "sqlite3mem"
+ENV["DB"] ||= "mysql"
 ActiveRecord::Base.table_name_prefix = ENV['DB_PREFIX'].to_s
 ActiveRecord::Base.table_name_suffix = ENV['DB_SUFFIX'].to_s
 ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result)
@@ -41,6 +42,8 @@ ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
   alias_method_chain :log, :query_append
 end
 
+Thread.abort_on_exception = true
+
 RSpec.configure do |config|
   config.fixture_path = "#{plugin_test_dir}/fixtures"
   # true runs the tests 1 second faster, but then you can't
@@ -49,4 +52,10 @@ RSpec.configure do |config|
   config.after(:each) do
     DB_QUERIES.clear
   end
+  config.before(:all) do
+    ENV['FLOCK_DIR'] = Dir.mktmpdir
+  end
+  config.after(:all) do
+    FileUtils.remove_entry_secure ENV['FLOCK_DIR']
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 3.6.9
+  version: 3.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-31 00:00:00.000000000 Z
+date: 2013-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: with_advisory_lock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -191,6 +207,7 @@ files:
 - spec/fixtures/tags.yml
 - spec/hash_tree_spec.rb
 - spec/label_spec.rb
+- spec/parallel_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/tag_spec.rb
@@ -209,7 +226,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2239773870557793017
+      hash: 2666801847924685333
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -218,7 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2239773870557793017
+      hash: 2666801847924685333
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -233,6 +250,7 @@ test_files:
 - spec/fixtures/tags.yml
 - spec/hash_tree_spec.rb
 - spec/label_spec.rb
+- spec/parallel_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/tag_spec.rb