with_advisory_lock 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a06363d16fb4769a2ee0486a8f0295dfe6e0c21
-  data.tar.gz: 3ce9cf5d558777ab689388fc086ce1fc2b18e1aa
+  metadata.gz: aeb99a0ddec77a51eeb59a41a26411a25390c65b
+  data.tar.gz: 3ee6f67835cbd6f3fe515f41b8134478ef2102ce
 SHA512:
-  metadata.gz: 1e162976296fc77f93eb8a46bf2681c4a7694727317a384b38bdfc552cd7dba6738a84e035879df673256624a6bdf3c0a74e16a677ce06adae80b2ee9daf59b8
-  data.tar.gz: 5454c4de4150ceaa24c797ae726913ed0b239fdfcbf19471985d760d76c41a2b78da3ea1df4c733afb1ba75301e02ae0550252876e3b3e4b145e4984b4c5e3b4
+  metadata.gz: 58919a4b30f793b056f8c9f2af7f06f40673f5e9e6ef68213760f49b348f9044087ab16a1b398619e7c47bcba14db7eecadaf50a6f5652bfa5e36bb0ef1d9fc7
+  data.tar.gz: a819c9b4d0c2607505b90f9dbb8f981c041c3608ae69a63e7dac621d105479be268b5d425f1ec946c225b36175d595ed2115782a9a239cd3ad671c6e3b25d665

data/.travis.yml

@@ -23,10 +23,9 @@ before_script:
   - mysql -e 'create database with_advisory_lock_test'
   - psql -c 'create database with_advisory_lock_test' -U postgres
 
-addons:
-  postgresql: "9.3"
-
 matrix:
   allow_failures:
     - gemfile: gemfiles/activerecord_edge.gemfile
+    - rvm: jruby-19mode # travis' version of jruby has issues. Tests pass with jruby 1.7.13/java 1.8.0_11 on mac.
     - rvm: rbx-2
+

data/README.md

@@ -41,9 +41,14 @@ A value of zero will try the lock only once. If the lock is acquired, the block
 will be yielded to. If the lock is currently being held, the block will not be called.
 
 Note that if a non-nil value is provided for `timeout_seconds`, the block will not be invoked if
-the lock cannot be acquired within that timeframe.
+the lock cannot be acquired within that time-frame.
 
 ### Return values
+
+The return value of `with_advisory_lock_result` is a `WithAdvisoryLock::Result` instance,
+which has a `lock_was_acquired?` method and a `result` accessor method, which is
+the returned value of the given block. If your block may validly return false, you should use
+this method.
  
 The return value of ```with_advisory_lock``` will be the result of the yielded block,
 if the lock was able to be acquired and the block yielded, or ```false```, if you provided
@@ -134,6 +139,20 @@ end
 
 ## Changelog
 
+### 3.0.0
+
+* Added jruby/PostgreSQL support for Rails 4.x 
+* Reworked threaded tests to allow jruby tests to pass
+
+#### API changes
+
+* `yield_with_lock_and_timeout` and `yield_with_lock` now return instances of
+  `WithAdvisoryLock::Result`, so blocks that return `false` are not misinterpreted
+  as a failure to lock. As this changes the interface (albeit internal methods), the major version
+  number was incremented.
+* `with_advisory_lock_result` was introduced, which clarifies whether the lock was acquired
+  versus the yielded block returned false.  
+ 
 ### 2.0.0
 
 * Lock timeouts of 0 now attempt the lock once, as per suggested by 

data/lib/with_advisory_lock/base.rb

@@ -1,6 +1,21 @@
 require 'zlib'
 
 module WithAdvisoryLock
+  class Result
+    attr_reader :result
+
+    def initialize(lock_was_acquired, result = false)
+      @lock_was_acquired = lock_was_acquired
+      @result = result
+    end
+
+    def lock_was_acquired?
+      @lock_was_acquired
+    end
+  end
+
+  FAILED_TO_LOCK = Result.new(false)
+
   class Base
     attr_reader :connection, :lock_name, :timeout_seconds
 
@@ -15,20 +30,22 @@ module WithAdvisoryLock
     end
 
     def self.lock_stack
+      # access doesn't need to be synchronized as it is only accessed by the current thread.
       Thread.current[:with_advisory_lock_stack] ||= []
     end
-
     delegate :lock_stack, to: 'self.class'
 
     def already_locked?
       lock_stack.include? lock_str
     end
 
-    def with_advisory_lock_if_needed
+    def with_advisory_lock_if_needed(&block)
       if already_locked?
-        yield
+        Result.new(true, yield)
+      elsif timeout_seconds == 0
+        yield_with_lock(&block)
       else
-        yield_with_lock { yield }
+        yield_with_lock_and_timeout(&block)
       end
     end
 
@@ -42,35 +59,35 @@ module WithAdvisoryLock
       end
     end
 
-    def advisory_lock_exists?
-      acquired_lock = try_lock
-    ensure
-      release_lock if acquired_lock
+    def yield_with_lock_and_timeout(&block)
+      give_up_at = Time.now + @timeout_seconds if @timeout_seconds
+      while @timeout_seconds.nil? || Time.now < give_up_at do
+        r = yield_with_lock(&block)
+        return r if r.lock_was_acquired?
+        # Randomizing sleep time may help reduce contention.
+        sleep(rand(0.05..0.15))
+      end
+      FAILED_TO_LOCK
     end
 
     def yield_with_lock
-      give_up_at = Time.now + @timeout_seconds if @timeout_seconds
-      begin
-        if try_lock
-          begin
-            lock_stack.push(lock_str)
-            return yield
-          ensure
-            lock_stack.pop
-            release_lock
-          end
-        else
-          # sleep between 1/20 and ~1/5 of a second.
-          # Randomizing sleep time may help reduce contention.
-          sleep(rand * 0.15 + 0.05)
+      if try_lock
+        begin
+          lock_stack.push(lock_str)
+          result = block_given? ? yield : nil
+          Result.new(true, result)
+        ensure
+          lock_stack.pop
+          release_lock
         end
-      end while @timeout_seconds.nil? || Time.now < give_up_at
-      false # failed to get lock in time.
+      else
+        FAILED_TO_LOCK
+      end
     end
 
-    # The timestamp prevents AR from caching the result improperly, and is ignored.
-    def query_cache_buster
-      "AS t#{(Time.now.to_f * 1000).to_i}"
+    # Prevent AR from caching results improperly
+    def unique_column_name
+      "t#{SecureRandom.hex}"
     end
   end
 end

data/lib/with_advisory_lock/concern.rb

@@ -1,23 +1,24 @@
-# Tried desperately to monkeypatch the polymorphic connection object,
-# but rails autoloading is too clever by half. Pull requests are welcome.
-
 require 'active_support/concern'
 
 module WithAdvisoryLock
   module Concern
     extend ActiveSupport::Concern
-
     delegate :with_advisory_lock, :advisory_lock_exists?, to: 'self.class'
 
     module ClassMethods
       def with_advisory_lock(lock_name, timeout_seconds=nil, &block)
+        result = with_advisory_lock_result(lock_name, timeout_seconds, &block)
+        result.lock_was_acquired? ? result.result : false
+      end
+
+      def with_advisory_lock_result(lock_name, timeout_seconds=nil, &block)
         impl = impl_class.new(connection, lock_name, timeout_seconds)
         impl.with_advisory_lock_if_needed(&block)
       end
 
       def advisory_lock_exists?(lock_name)
         impl = impl_class.new(connection, lock_name, 0)
-        impl.already_locked? || !impl.yield_with_lock { true }
+        impl.already_locked? || !impl.yield_with_lock.lock_was_acquired?
       end
 
       def current_advisory_lock
@@ -27,12 +28,12 @@ module WithAdvisoryLock
       private
 
       def impl_class
-        case WithAdvisoryLock::DatabaseAdapterSupport.new(connection).adapter
-        when :postgresql
+        adapter = WithAdvisoryLock::DatabaseAdapterSupport.new(connection)
+        if adapter.postgresql?
           WithAdvisoryLock::PostgreSQL
-        when :mysql
+        elsif adapter.mysql?
           WithAdvisoryLock::MySQL
-        else #sqlite
+        else
           WithAdvisoryLock::Flock
         end
       end

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -15,11 +15,5 @@ module WithAdvisoryLock
     def sqlite?
       :sqlite3 == @sym_name
     end
-
-    def adapter
-      return :mysql if mysql?
-      return :postgresql if postgresql?
-      :sqlite3
-    end
   end
 end

data/lib/with_advisory_lock/mysql.rb

@@ -7,20 +7,15 @@ module WithAdvisoryLock
           "MySQL doesn't support nested Advisory Locks",
           lock_stack.dup)
       end
-      # Returns 1 if the lock was obtained successfully,
-      # 0 if the attempt timed out (for example, because another client has
-      # previously locked the name), or NULL if an error occurred
-      # (such as running out of memory or the thread was killed with mysqladmin kill).
-      sql = "SELECT GET_LOCK(#{quoted_lock_str}, 0) #{query_cache_buster}"
-      connection.select_value(sql).to_i > 0
+      execute_successful?("GET_LOCK(#{quoted_lock_str}, 0)")
     end
 
     def release_lock
-      # Returns > 0 if the lock was released,
-      # 0 if the lock was not established by this thread
-      # (in which case the lock is not released), and
-      # NULL if the named lock did not exist.
-      sql = "SELECT RELEASE_LOCK(#{quoted_lock_str}) #{query_cache_buster}"
+      execute_successful?("RELEASE_LOCK(#{quoted_lock_str})")
+    end
+
+    def execute_successful?(mysql_function)
+      sql = "SELECT #{mysql_function} AS #{unique_column_name}"
       connection.select_value(sql).to_i > 0
     end
 

data/lib/with_advisory_lock/postgresql.rb

@@ -2,15 +2,18 @@ module WithAdvisoryLock
   class PostgreSQL < Base
     # See http://www.postgresql.org/docs/9.1/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
     def try_lock
-      # pg_try_advisory_lock will either obtain the lock immediately and return true
-      # or return false if the lock cannot be acquired immediately
-      sql = "SELECT pg_try_advisory_lock(#{lock_keys.join(',')}) #{query_cache_buster}"
-      't' == connection.select_value(sql).to_s
+      execute_successful?('pg_try_advisory_lock')
     end
 
     def release_lock
-      sql = "SELECT pg_advisory_unlock(#{lock_keys.join(',')}) #{query_cache_buster}"
-      't' == connection.select_value(sql).to_s
+      execute_successful?('pg_advisory_unlock')
+    end
+
+    def execute_successful?(pg_function)
+      sql = "SELECT #{pg_function}(#{lock_keys.join(',')}) AS #{unique_column_name}"
+      result = connection.select_value(sql)
+      # MRI returns 't', jruby returns true. YAY!
+      (result == 't' || result == true)
     end
 
     # PostgreSQL wants 2 32bit integers as the lock key.

data/lib/with_advisory_lock/version.rb

@@ -1,3 +1,3 @@
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('2.0.0')
+  VERSION = Gem::Version.new('3.0.0')
 end

data/test/lock_test.rb

@@ -1,22 +1,23 @@
 require 'minitest_helper'
 
 describe 'class methods' do
-  let(:lock_name) { "test lock #{rand(1024)}" }
+  let(:lock_name) { 'test lock' }
 
   describe '.current_advisory_lock' do
-    it "returns nil outside an advisory lock request" do
+    it 'returns nil outside an advisory lock request' do
       Tag.current_advisory_lock.must_be_nil
     end
 
     it 'returns the name of the last lock acquired' do
       Tag.with_advisory_lock(lock_name) do
+        # The lock name may have a prefix if WITH_ADVISORY_LOCK_PREFIX env is set
         Tag.current_advisory_lock.must_match /#{lock_name}/
       end
     end
   end
 
   describe '.advisory_lock_exists?' do
-    it "returns false for an unacquired lock" do
+    it 'returns false for an unacquired lock' do
       Tag.advisory_lock_exists?(lock_name).must_be_false
     end
 
@@ -27,13 +28,12 @@ describe 'class methods' do
     end
   end
 
-  describe "0 timeout" do
+  describe 'zero timeout_seconds' do
     it 'attempts the lock exactly once with no timeout' do
-      block_was_yielded = false
+      expected = SecureRandom.base64
       Tag.with_advisory_lock(lock_name, 0) do
-        block_was_yielded = true
-      end
-      block_was_yielded.must_be_true
+        expected
+      end.must_equal expected
     end
   end
 end

data/test/minitest_helper.rb

@@ -4,14 +4,14 @@ require 'with_advisory_lock'
 require 'tmpdir'
 require 'securerandom'
 
-db_config = File.expand_path("database.yml", File.dirname(__FILE__))
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(db_config)).result)
-
 def env_db
-  (ENV["DB"] || :mysql).to_sym
+  (ENV['DB'] || :mysql).to_sym
 end
 
-ENV["WITH_ADVISORY_LOCK_PREFIX"] ||= SecureRandom.base64
+db_config = File.expand_path('database.yml', File.dirname(__FILE__))
+ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(db_config)).result)
+
+ENV['WITH_ADVISORY_LOCK_PREFIX'] ||= SecureRandom.hex
 
 ActiveRecord::Base.establish_connection(env_db)
 ActiveRecord::Migration.verbose = false
@@ -19,14 +19,18 @@ ActiveRecord::Migration.verbose = false
 require 'test_models'
 begin
   require 'minitest'
-rescue LoadError => rails_four_zero_is_lame
+rescue LoadError
+  puts 'Failed to load the minitest gem; built-in version will be used.'
 end
 require 'minitest/autorun'
 require 'minitest/great_expectations'
+if ActiveRecord::VERSION::MAJOR > 3
+  # minitest-reporters-1.0.5/lib/minitest/old_activesupport_fix.rb:7:in `remove_method': method `run' not defined in ActiveSupport::Testing::SetupAndTeardown::ForMinitest (NameError)
+  require 'minitest/reporters'
+  Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+end
 require 'mocha/setup'
 
-Thread.abort_on_exception = true
-
 class MiniTest::Spec
   before do
     ENV['FLOCK_DIR'] = Dir.mktmpdir

data/test/parallelism_test.rb

@@ -1,45 +1,52 @@
 require 'minitest_helper'
+require 'forwardable'
 
-describe "parallelism" do
+describe 'parallelism' do
   class FindOrCreateWorker
-    def initialize(target, run_at, name, use_advisory_lock)
-      @thread = Thread.new do
-        ActiveRecord::Base.connection_pool.with_connection do
-          sleep((run_at - Time.now).to_f)
-          if use_advisory_lock
-            Tag.with_advisory_lock(name) { work(name) }
-          else
-            work(name)
-          end
+    extend Forwardable
+    def_delegators :@thread, :join, :wakeup, :join, :status, :to_s
+
+    def initialize(name, use_advisory_lock)
+      @name = name
+      @use_advisory_lock = use_advisory_lock
+      @thread = Thread.new { work_later }
+    end
+
+    def work_later
+      sleep
+      ActiveRecord::Base.connection_pool.with_connection do
+        if @use_advisory_lock
+          Tag.with_advisory_lock(@name) { work }
+        else
+          work
         end
       end
     end
 
-    def work(name)
+    def work
       Tag.transaction do
-        Tag.where(name: name).first_or_create
+        Tag.where(name: @name).first_or_create
       end
     end
-
-    def join
-      @thread.join
-    end
   end
 
   def run_workers
-    all_workers = []
     @names = @iterations.times.map { |iter| "iteration ##{iter}" }
     @names.each do |name|
-      wake_time = 1.second.from_now
       workers = @workers.times.map do
-        FindOrCreateWorker.new(@target, wake_time, name, @use_advisory_lock)
+        FindOrCreateWorker.new(name, @use_advisory_lock)
+      end
+      # Wait for all the threads to get ready:
+      until workers.all? { |ea| ea.status == 'sleep' }
+        sleep(0.1)
       end
+      # OK, GO!
+      workers.each(&:wakeup)
+      # Then wait for them to finish:
       workers.each(&:join)
-      all_workers += workers
     end
     # Ensure we're still connected:
     ActiveRecord::Base.connection_pool.connection
-    all_workers
   end
 
   before :each do
@@ -47,14 +54,14 @@ describe "parallelism" do
     @workers = 10
   end
 
-  it "creates multiple duplicate rows without advisory locks" do
+  it 'creates multiple duplicate rows without advisory locks' do
     @use_advisory_lock = false
     @iterations = 1
     run_workers
     Tag.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
     TagAudit.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
     Label.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
-  end unless env_db == :sqlite
+  end unless env_db == :sqlite # < SQLite, understandably, throws "The database file is locked (database is locked)"
 
   it "doesn't create multiple duplicate rows with advisory locks" do
     @use_advisory_lock = true
@@ -66,50 +73,3 @@ describe "parallelism" do
   end
 end
 
-describe "separate thread tests" do
-  let(:lock_name) { "testing 1,2,3" }
-
-  before do
-    @t1_acquired_lock = false
-    @t1_return_value = nil
-
-    @t1 = Thread.new do
-      ActiveRecord::Base.connection_pool.with_connection do
-        @t1_return_value = Label.with_advisory_lock(lock_name) do
-          t1_acquired_lock = true
-          sleep(0.4)
-          't1 finished'
-        end
-      end
-    end
-
-    # Wait for the thread to acquire the lock:
-    sleep(0.1)
-    ActiveRecord::Base.connection.reconnect!
-  end
-
-  after do
-    @t1.join
-  end
-
-  it "#with_advisory_lock with a 0 timeout returns false immediately" do
-    response = Label.with_advisory_lock(lock_name, 0) {}
-    response.must_be_false
-  end
-
-  it "#advisory_lock_exists? returns true when another thread has the lock" do
-    Tag.advisory_lock_exists?(lock_name).must_be_true
-  end
-
-  it "can re-establish the lock after the other thread releases it" do
-    @t1.join
-    @t1_return_value.must_equal 't1 finished'
-
-    # We should now be able to acquire the lock immediately:
-    reacquired = false
-    Label.with_advisory_lock(lock_name, 0) do
-      reacquired = true
-    end.must_be_true
-    reacquired.must_be_true
-  end
-end

data/test/thread_test.rb

@@ -0,0 +1,60 @@
+require 'minitest_helper'
+
+describe 'separate thread tests' do
+  let(:lock_name) { 'testing 1,2,3' } # OMG COMMAS
+
+  before do
+    @mutex = Mutex.new
+    @t1_acquired_lock = false
+    @t1_return_value = nil
+
+    @t1 = Thread.new do
+      ActiveRecord::Base.connection_pool.with_connection do
+        @t1_return_value = Label.with_advisory_lock(lock_name) do
+          @mutex.synchronize { @t1_acquired_lock = true }
+          sleep
+          't1 finished'
+        end
+      end
+    end
+
+    # Wait for the thread to acquire the lock:
+    until @mutex.synchronize { @t1_acquired_lock } do
+      sleep(0.1)
+    end
+    ActiveRecord::Base.connection.reconnect!
+  end
+
+  after do
+    @t1.wakeup if @t1.status == 'sleep'
+    @t1.join
+  end
+
+  it '#with_advisory_lock with a 0 timeout returns false immediately' do
+    response = Label.with_advisory_lock(lock_name, 0) do
+      fail 'should not be yielded to'
+    end
+    response.must_be_false
+  end
+
+  it '#with_advisory_lock yields to the provided block' do
+    @t1_acquired_lock.must_be_true
+  end
+
+  it '#advisory_lock_exists? returns true when another thread has the lock' do
+    Tag.advisory_lock_exists?(lock_name).must_be_true
+  end
+
+  it 'can re-establish the lock after the other thread releases it' do
+    @t1.wakeup
+    @t1.join
+    @t1_return_value.must_equal 't1 finished'
+
+    # We should now be able to acquire the lock immediately:
+    reacquired = false
+    Label.with_advisory_lock(lock_name, 0) do
+      reacquired = true
+    end.must_be_true
+    reacquired.must_be_true
+  end
+end

data/tests.sh

@@ -1,11 +1,11 @@
 #!/bin/bash -e
 export DB
 
-for RUBY in 2.1.2 jruby-1.7.12 ; do
+for RUBY in 2.1.2 jruby-1.7.13 ; do
   rbenv local $RUBY
   for DB in mysql postgresql sqlite ; do
     echo "$DB | $(ruby -v)"
-    appraisal bundle update
-    appraisal rake test
+#    appraisal bundle update
+    appraisal rake test --verbose
   done
 done

data/with_advisory_lock.gemspec

@@ -19,11 +19,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = %w(lib)
 
   gem.add_runtime_dependency 'activerecord', '>= 3.2'
+  gem.add_runtime_dependency 'thread_safe'
 
-  gem.add_development_dependency 'rake'
   gem.add_development_dependency 'yard'
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'minitest-great_expectations'
+  gem.add_development_dependency 'minitest-reporters'
   gem.add_development_dependency 'mocha'
   gem.add_development_dependency 'appraisal'
 end

metadata

@@ -1,111 +1,125 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Matthew McEachen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
-  type: :runtime
+  name: activerecord
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: thread_safe
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: yard
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: minitest
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-great_expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: minitest-great_expectations
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: minitest-reporters
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  name: mocha
+  prerelease: false
   type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: appraisal
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Advisory locking for ActiveRecord
@@ -115,8 +129,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - Appraisals
 - Gemfile
 - LICENSE.txt
@@ -142,30 +156,31 @@ files:
 - test/nesting_test.rb
 - test/parallelism_test.rb
 - test/test_models.rb
+- test/thread_test.rb
 - tests.sh
 - with_advisory_lock.gemspec
 homepage: https://github.com/mceachen/with_advisory_lock
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.3.0
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
 specification_version: 4
 summary: Advisory locking for ActiveRecord
 test_files:
@@ -176,4 +191,5 @@ test_files:
 - test/nesting_test.rb
 - test/parallelism_test.rb
 - test/test_models.rb
-has_rdoc: 
+- test/thread_test.rb
+has_rdoc: