activerecord-tablelocks 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-tablelocks.gemspec
+gemspec
+
+gem 'pg'
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sernin van de Krol
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+## ActiveRecord Tablelocks
+
+This gem adds table locking functionality to ActiveRecord.
+Every save and destroy action is already done using a transaction, but now you can add locking to this process to make sure you really have unique records.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-tablelocks'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-tablelocks
+
+## Usage
+
+In your models use the following to lock the table when editing records:
+
+    class User < ActiveRecord::Base
+        validates :login, :uniqueness => true, :presence => true
+        # The following line enables locking to make sure the uniqueness constraint holds.
+        enable_locking
+    end
+
+If you need to lock multiple table, you can specify this in two ways.
+
+Using class names:
+
+    class EmailBox < ActiveRecord::Base
+        enable_locking :class_names => ['EmailAlias']
+        # The class name needs to be a String, but doesn't need to be in an Array.
+        # Don't forget to add validations, this gem doesn't do that for you.
+    end
+
+Using table names:
+
+    class EmailAlias < ActiveRecord::Base
+        enable_locking :table_names => ['email_boxes']
+        # The table name needs to be a String, but doesn't need to be in an Array.
+        # The gem quotes the table name for you, so you don't need to that here.
+        # Don't forget to add validations, this gem doesn't do that for you.
+    end
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activerecord-tablelocks.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord/tablelocks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-tablelocks"
+  spec.version       = Activerecord::Tablelocks::VERSION
+  spec.authors       = ["Sernin van de Krol"]
+  spec.email         = ["serninpc@paneidos.net"]
+  spec.description   = %q{This gem enables the use of database specific table locks when saving or destroying your ActiveRecord objects. This ensures no race conditions exist when using e.g. validates_uniqueness_of.}
+  spec.summary       = %q{Use native table locks of your database for your ActiveRecord models}
+  spec.homepage      = "https://github.com/paneidos/activerecord-tablelocks"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 3.2.0"
+
+  spec.add_development_dependency "bundler", ">= 1.2"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "railties"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+end

data/lib/activerecord-tablelocks.rb

@@ -0,0 +1,9 @@
+require 'active_support'
+
+if defined? Rails
+  require 'activerecord/tablelocks/railties'
+else
+  ActiveSupport.on_load :active_record do
+    require 'activerecord/tablelocks/activerecord'
+  end
+end

data/lib/activerecord/tablelocks/activerecord.rb

@@ -0,0 +1,56 @@
+# Extends AR to add table locking
+module ActiveRecord
+  class Base
+    class << self
+      attr_reader :locking_enabled
+
+      def enable_locking(options = {})
+        @locking_enabled = true
+        @lock_targets = {
+          :class_names => [*options[:class_names]].compact,
+          :table_names => [*options[:table_names]].compact
+        }
+      end
+
+      def lock_targets
+        @lock_targets ||= {
+          :class_names => [],
+          :table_names => []
+        }
+      end
+
+      def tables_to_lock
+        return [] unless @locking_enabled
+        [quoted_table_name,
+          *@lock_targets[:table_names].map{|table_name| connection.quote_table_name(table_name) },
+          *@lock_targets[:class_names].map{|class_name| class_name.constantize.quoted_table_name }].sort.uniq
+      end
+    end
+
+    def add_to_transaction
+      if self.class.locking_enabled
+        self.class.connection.lock_tables self.class.tables_to_lock
+      end
+      super
+    end
+  end
+  module ConnectionAdapters
+    class AbstractAdapter
+      def self.inherited(subclass)
+        case subclass.name
+        when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+          require 'activerecord/tablelocks/activerecord/postgres'
+        end
+      end
+      def lock_table(quoted_table_name)
+        logger.warn "WARNING: Locking is not supported for your database!"
+      end
+      def lock_tables(quoted_table_names)
+        logger.warn "WARNING: Locking is not supported for your database!"
+      end
+    end
+    if defined?(PostgreSQLAdapter)
+      require 'activerecord/tablelocks/activerecord/postgres'
+    end
+  end
+end

data/lib/activerecord/tablelocks/activerecord/postgres.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      def lock_table(quoted_table_name)
+        execute "LOCK TABLE #{quoted_table_name} IN EXCLUSIVE MODE"
+      end
+      def lock_tables(quoted_table_names)
+        quoted_table_names.each do |quoted_table_name|
+          lock_table quoted_table_name
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/tablelocks/railtie.rb

@@ -0,0 +1,10 @@
+require 'rails'
+
+class Tablelocks < Rails::Railtie
+
+  initializer 'activerecord-tablelocks' do
+    ActiveSupport.on_load :active_record do
+      require 'activerecord/tablelocks/activerecord'
+    end
+  end
+end

data/lib/activerecord/tablelocks/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module Tablelocks
+    VERSION = "0.0.1"
+  end
+end

data/spec/extension_methods_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+describe "Extension methods" do
+  describe "ActiveRecord objects" do
+    it "should accept zero arguments for 'enable_locking'" do
+      klass = Class.new(ActiveRecord::Base)
+      lambda { klass.enable_locking }.should_not raise_error
+    end
+
+    it "should accept a hash with options" do
+      klass = Class.new(ActiveRecord::Base)
+      lambda { klass.enable_locking({}) }.should_not raise_error
+    end
+
+    it "should have an empty list at the start" do
+      klass = Class.new(ActiveRecord::Base)
+      klass.lock_targets[:class_names].should == []
+      klass.lock_targets[:table_names].should == []
+    end
+
+    it "should save class_names and table_names from options" do
+      klass = Class.new(ActiveRecord::Base)
+      klass.enable_locking({ class_names: ['User', 'Group'], table_names: ['users_groups'] })
+      klass.lock_targets[:class_names].sort.should == ['Group','User']
+      klass.lock_targets[:table_names].sort.should == ['users_groups']
+    end
+  end
+end

data/spec/locking_targets_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'models/page'
+require 'models/comment'
+require 'models/user'
+require 'models/group'
+
+describe "Locking target" do
+  it "should be empty by default" do
+    Page.tables_to_lock.should == []
+  end
+
+  it "should include the class' own table by default" do
+    Comment.tables_to_lock.should include(Comment.quoted_table_name)
+  end
+
+  it "should include all specified classes" do
+    User.tables_to_lock.should include(User.quoted_table_name)
+    User.tables_to_lock.should include(Group.quoted_table_name)
+  end
+
+  it "should include all specified tables" do
+    Group.tables_to_lock.should include(User.quoted_table_name)
+    Group.tables_to_lock.should include(Group.quoted_table_name)
+  end
+
+  it "should have the tables to lock sorted" do
+    User.tables_to_lock.sort.should == User.tables_to_lock
+    Comment.tables_to_lock.sort.should == Comment.tables_to_lock
+    Page.tables_to_lock.sort.should == Page.tables_to_lock
+    Group.tables_to_lock.sort.should == Group.tables_to_lock
+  end
+
+  it "should not contain duplicate table names" do
+    User.tables_to_lock.uniq.should == User.tables_to_lock
+    Comment.tables_to_lock.uniq.should == Comment.tables_to_lock
+    Page.tables_to_lock.uniq.should == Page.tables_to_lock
+    Group.tables_to_lock.uniq.should == Group.tables_to_lock
+  end
+end

data/spec/models/comment.rb

@@ -0,0 +1,30 @@
+class Comment < ActiveRecord::Base
+  enable_locking
+  validates :title, :uniqueness => true, :presence => true
+
+
+  attr_accessor :validate_mutexes
+  attr_accessor :commit_mutexes
+  attr_accessor :wait_time
+  after_validation :release_mutexes
+  after_validation :wait
+
+  def wait
+    if wait_time.present?
+      sleep wait_time
+    end
+  end
+
+  def release_mutexes
+    if validate_mutexes.present?
+      validate_mutexes.each do |mutex|
+        mutex.unlock
+      end
+    end
+    if commit_mutexes.present?
+      commit_mutexes.each do |mutex|
+        mutex.lock
+      end
+    end
+  end
+end

data/spec/models/group.rb

@@ -0,0 +1,22 @@
+class Group < ActiveRecord::Base
+  enable_locking :table_names => "users", :class_names => "User"
+
+  validates :name, :uniqueness => true, :presence => true
+
+
+
+
+  
+  attr_accessor :validate_mutexes
+  attr_accessor :commit_mutexes
+  after_validation :release_mutexes
+
+  def release_mutexes
+    validate_mutexes.each do |mutex|
+      mutex.unlock
+    end
+    commit_mutexes.each do |mutex|
+      mutex.lock
+    end
+  end
+end

data/spec/models/page.rb

@@ -0,0 +1,3 @@
+class Page < ActiveRecord::Base
+  # No validators in here
+end

data/spec/models/user.rb

@@ -0,0 +1,18 @@
+class User < ActiveRecord::Base
+  enable_locking :class_names => "Group"
+
+  validates :name, :uniqueness => true, :presence => true
+
+  attr_accessor :validate_mutexes
+  attr_accessor :commit_mutexes
+  after_validation :release_mutexes
+
+  def release_mutexes
+    validate_mutexes.each do |mutex|
+      mutex.unlock
+    end
+    commit_mutexes.each do |mutex|
+      mutex.lock
+    end
+  end
+end

data/spec/normal_behaviour_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'models/page'
+
+describe "Normal behaviour" do
+  it "is not affected by this gem" do
+    page = Page.new(name: "Home", content: "Lorem ipsum dolor, ... you know this.")
+    page.save.should == true
+  end
+end

data/spec/race_conditions_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+require 'models/comment'
+
+describe "Race conditions" do
+  it "should prevent race conditions on a single table" do
+    comment1 = Comment.new(title: "TITLE")
+    comment2 = Comment.new(title: "TITLE")
+
+    mutex1 = Mutex.new
+    mutex2 = Mutex.new
+    mutex3 = Mutex.new
+    mutex4 = Mutex.new
+
+    # This should not run within reasonable time
+
+    # main thread:
+    # 1. lock mutex1
+    # 2. lock mutex2
+    # 3. start threads
+    # 4. wait for mutex3 and mutex4 to be locked
+    # 4. release mutex1 and mutex2
+
+    # comment1:
+    # 0. lock mutex3
+    # 1. lock mutex1
+    # 2. run validations
+    # 3. release mutex1 and mutex3
+    # 4. lock mutex4
+    # 5. commit
+    # 6. release mutex4
+
+    # comment2:
+    # 1. lock mutex4
+    # 2. lock mutex2
+    # 2. run validations
+    # 3. release mutex2 and mutex4
+    # 4. lock mutex3
+    # 5. commit
+    # 6. release mutex3
+
+    mutex1.lock
+    mutex2.lock
+
+    comment1.validate_mutexes = [mutex1,mutex3]
+    comment1.commit_mutexes = [mutex4]
+    comment2.validate_mutexes = [mutex2,mutex4]
+    comment2.commit_mutexes = [mutex3]
+
+    # Start threads
+    thread1 = Thread.new do
+      mutex3.lock
+      mutex1.lock
+      ActiveRecord::Base.connection_pool.with_connection do |conn|
+        comment1.save
+      end
+      mutex4.unlock
+    end
+
+    thread2 = Thread.new do
+      mutex4.lock
+      mutex2.lock
+      ActiveRecord::Base.connection_pool.with_connection do |conn|
+        comment2.save
+      end
+      mutex3.unlock
+    end
+
+    until mutex3.locked?
+      sleep 0.001
+    end
+    until mutex4.locked?
+      sleep 0.001
+    end
+
+    mutex1.unlock
+    mutex2.unlock
+    thread1.join(3).should be_nil
+    thread2.join(3).should be_nil
+
+    comment1.persisted?.should == false
+    comment2.persisted?.should == false
+
+    # Clean up the threads
+    thread1.exit
+    thread2.exit
+
+  end
+  it "should prevent race conditions on validations spanning multiple tables" do
+    user = User.new(name: "root")
+    group = Group.new(name: "root")
+
+    mutex1 = Mutex.new
+    mutex2 = Mutex.new
+    mutex3 = Mutex.new
+    mutex4 = Mutex.new
+
+    # This should not run within reasonable time
+
+    # main thread:
+    # 1. lock mutex1
+    # 2. lock mutex2
+    # 3. start threads
+    # 4. wait for mutex3 and mutex4 to be locked
+    # 4. release mutex1 and mutex2
+
+    # user:
+    # 0. lock mutex3
+    # 1. lock mutex1
+    # 2. run validations
+    # 3. release mutex1 and mutex3
+    # 4. lock mutex4
+    # 5. commit
+    # 6. release mutex4
+
+    # group:
+    # 1. lock mutex4
+    # 2. lock mutex2
+    # 2. run validations
+    # 3. release mutex2 and mutex4
+    # 4. lock mutex3
+    # 5. commit
+    # 6. release mutex3
+
+    mutex1.lock
+    mutex2.lock
+
+    user.validate_mutexes = [mutex1,mutex3]
+    user.commit_mutexes = [mutex4]
+    group.validate_mutexes = [mutex2,mutex4]
+    group.commit_mutexes = [mutex3]
+
+    # Start threads
+    thread1 = Thread.new do
+      mutex3.lock
+      mutex1.lock
+      ActiveRecord::Base.connection_pool.with_connection do |conn|
+        user.save
+      end
+      mutex4.unlock
+    end
+
+    thread2 = Thread.new do
+      mutex4.lock
+      mutex2.lock
+      ActiveRecord::Base.connection_pool.with_connection do |conn|
+        group.save
+      end
+      mutex3.unlock
+    end
+
+    until mutex3.locked?
+      sleep 0.001
+    end
+    until mutex4.locked?
+      sleep 0.001
+    end
+
+    mutex1.unlock
+    mutex2.unlock
+    thread1.join(3).should be_nil
+    thread2.join(3).should be_nil
+
+    user.persisted?.should == false
+    group.persisted?.should == false
+
+    # Clean up the threads
+    thread1.exit
+    thread2.exit
+  end
+
+  it "should pass a test which tries to create a huge amount of comments at roughly the same time with random times between validation and saving to the database" do
+    puts "This test will take a long time"
+    comments = []
+    threads = []
+    number_of_comments = 100
+    timeouts = AtomicInteger.new
+    # The wait times are sorted in reverse order to increase the chance of a race condition
+    wait_times = list_of_random_numbers(number_of_comments).sort.reverse
+    number_of_comments.times do
+      comment = Comment.new title: "RACE"
+      comment.wait_time = wait_times.shift
+      comments << comment
+      threads << Thread.new do
+        saved = false
+        until saved do
+          begin
+            ActiveRecord::Base.connection_pool.with_connection do |conn|
+              comment.save
+              saved = true
+            end
+          rescue ActiveRecord::ConnectionTimeoutError => e
+            # This test most likely triggers a lot of timeout errors
+            # We can safely ignore those errors, it's intended behaviour of this test
+            # To improve the accuracy of the tests, it's recommended to increase the poolsize
+            timeouts.increment
+          end
+        end
+      end
+    end
+    threads.each do |thread|
+      thread.join
+    end
+    comments.map(&:persisted?).select {|x| x == true}.size.should == 1
+    if timeouts.value > 0
+      puts "There were #{timeouts.value} timeouts during this test, increase your database connection pool size to improve accuracy"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'activerecord-tablelocks'
+require 'rspec'
+require 'rspec/autorun'
+require 'active_record'
+
+Dir[File.join(File.dirname(__FILE__),"support/**/*.rb")].each { |f| require f }
+
+# For more progress output during the long test, uncomment the line below
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+RSpec.configure do |config|
+end

data/spec/support/atomic_integer.rb

@@ -0,0 +1,14 @@
+class AtomicInteger
+  attr_reader :value
+
+  def initialize
+    @value = 0
+    @mutex = Mutex.new
+  end
+
+  def increment
+    @mutex.synchronize do
+      @value = @value + 1
+    end
+  end
+end

data/spec/support/database.rb

@@ -0,0 +1,39 @@
+config = case ENV["ENGINE"]
+when "postgres"
+  {
+    "adapter" => "postgresql",
+    "database" => ENV["DATABASE"],
+    "username" => ENV["USERNAME"],
+    "password" => ENV["PASSWORD"],
+    "pool" => "15"
+  }
+else
+  raise "Only Postgres is supported at this time"
+end
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.configurations = { "test" => config }
+ActiveRecord::Base.establish_connection("test")
+ActiveRecord::Base.default_timezone = :utc
+
+
+ActiveRecord::Schema.define do
+  ActiveRecord::Base.connection.tables.each do |table|
+    drop_table table
+  end
+  create_table :pages do |t|
+    t.string :name
+    t.text :content
+  end
+  create_table :comments do |t|
+    t.string :title
+    t.text :content
+  end
+  create_table :users do |t|
+    t.string :name
+  end
+  create_table :groups do |t|
+    t.string :name
+  end
+  
+end

data/spec/support/random.rb

@@ -0,0 +1,6 @@
+def list_of_random_numbers(count)
+  Kernel.srand RSpec.configuration.seed
+  result = count.times.map { Kernel.rand }
+  Kernel.srand # reset random generation
+  result
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-tablelocks
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sernin van de Krol
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: This gem enables the use of database specific table locks when saving
+  or destroying your ActiveRecord objects. This ensures no race conditions exist when
+  using e.g. validates_uniqueness_of.
+email:
+- serninpc@paneidos.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-tablelocks.gemspec
+- lib/activerecord-tablelocks.rb
+- lib/activerecord/tablelocks/activerecord.rb
+- lib/activerecord/tablelocks/activerecord/postgres.rb
+- lib/activerecord/tablelocks/railtie.rb
+- lib/activerecord/tablelocks/version.rb
+- spec/extension_methods_spec.rb
+- spec/locking_targets_spec.rb
+- spec/models/comment.rb
+- spec/models/group.rb
+- spec/models/page.rb
+- spec/models/user.rb
+- spec/normal_behaviour_spec.rb
+- spec/race_conditions_spec.rb
+- spec/spec_helper.rb
+- spec/support/atomic_integer.rb
+- spec/support/database.rb
+- spec/support/random.rb
+homepage: https://github.com/paneidos/activerecord-tablelocks
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3007498809683035239
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3007498809683035239
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Use native table locks of your database for your ActiveRecord models
+test_files:
+- spec/extension_methods_spec.rb
+- spec/locking_targets_spec.rb
+- spec/models/comment.rb
+- spec/models/group.rb
+- spec/models/page.rb
+- spec/models/user.rb
+- spec/normal_behaviour_spec.rb
+- spec/race_conditions_spec.rb
+- spec/spec_helper.rb
+- spec/support/atomic_integer.rb
+- spec/support/database.rb
+- spec/support/random.rb