activerecord-batch_touching 1.0.pre.beta → 1.0.pre.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 829e262f5bb2081c84c1d8baea4afc937806119fbc605a0f13b5bccaecbf9616
-  data.tar.gz: ed048b0b157de0f9e6dbf6dcdfe08253c95177759e692fe718eda84f7460d0d5
+  metadata.gz: 8e3ae09116c725e745e467afa1d834b6b2a28bcae4f01d5346e598235bb7d0a8
+  data.tar.gz: 842acced5ccc6df3149f4ae60b2b7f574f1bf04a553a67b54d6832c1501b94ee
 SHA512:
-  metadata.gz: 625f5ed7a40621a366cd5c110a23d7f1a4048b92d7568feec17206c6f72d3507a6d4f4a1862f472147e980f0b632420ff0afe70372c297716718ec00b6c6671f
-  data.tar.gz: 52ba63a3c2df1cb8431ab5f17703cf51021250bba311bdcd483657ae24f4ebef5a86299c0a9e84b8869a08a08821b6188e417cdb08f62f09d9d8ec482208d725
+  metadata.gz: 5339c3f783b5b4e8f667a47437fa26e507353d648fd99f637ea73925c28d07d626c7eeb9a8850552ae4182ebb1d36ae9acb5acbe0e2d42e7b0d9f1664a0d86d7
+  data.tar.gz: bf5025309b66d19d7571ef34a3701eb23d9d8c054b68619bb6ad1f881439b37eb99e2a6fdd67e53dbadccf585ea41ae2703ee09fe10d3a81dd9e422675aa8b56

data/lib/activerecord/batch_touching.rb

@@ -2,6 +2,36 @@ require "activerecord/batch_touching/version"
 require "activerecord/batch_touching/state"
 
 module ActiveRecord
+  module BatchTouchingAbstractAdapter
+    # Batches up +touch+ calls for the duration of a transaction.
+    # +after_touch+ callbacks are also delayed until the transaction is committed.
+    #
+    # ==== Examples
+    #
+    #   # Touches Person.first and Person.last in a single database round-trip.
+    #   Person.transaction do
+    #     Person.first.touch
+    #     Person.last.touch
+    #   end
+    #
+    #   # Touches Person.first once, not twice, right before the transaction is committed.
+    #   Person.transaction do
+    #     Person.first.touch
+    #     Person.first.touch
+    #   end
+    def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
+      super(requires_new: requires_new, isolation: isolation, joinable: joinable) do
+        BatchTouching.start(requires_new: requires_new, &block)
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    class AbstractAdapter
+      prepend BatchTouchingAbstractAdapter
+    end
+  end
+
   # = Active Record Batch Touching
   module BatchTouching # :nodoc:
     extend ActiveSupport::Concern
@@ -9,7 +39,7 @@ module ActiveRecord
     # Override ActiveRecord::Base#touch_later.  This will effectively disable the current built-in mechanism AR uses
     # to delay touching in favor of our method of batch touching.
     def touch_later(*names)
-      touch(*names)
+      BatchTouching.batch_touching? ? touch(*names) : super
     end
 
     # Override ActiveRecord::Base#touch.  If currently batching touches, always return
@@ -24,33 +54,29 @@ module ActiveRecord
       end
     end
 
-    # These get added as class methods to ActiveRecord::Base.
-    module ClassMethods
-      # Batches up +touch+ calls for the duration of a transaction.
-      # +after_touch+ callbacks are also delayed until the transaction is committed.
-      #
-      # ==== Examples
-      #
-      #   # Touches Person.first and Person.last in a single database round-trip.
-      #   Person.transaction do
-      #     Person.first.touch
-      #     Person.last.touch
-      #   end
-      #
-      #   # Touches Person.first once, not twice, right before the transaction is committed.
-      #   Person.transaction do
-      #     Person.first.touch
-      #     Person.first.touch
-      #   end
-      #
-      def transaction(**options, &block)
-        super(**options) do
-          BatchTouching.start(**options, &block)
-        end
+    class << self
+      # Disable batch touching globally
+      def disable!
+        @disabled = true
+      end
+
+      # Enable batch touching globally
+      def enable!
+        @disabled = false
+      end
+
+      # Disable batch touching for a block
+      def disable
+        Thread.current[:batch_touching_disabled] = false
+        yield
+      ensure
+        Thread.current[:batch_touching_disabled] = false
+      end
+
+      def disabled?
+        Thread.current[:batch_touching_disabled] || @disabled
       end
-    end
 
-    class << self
       def states
         Thread.current[:batch_touching_states] ||= []
       end
@@ -62,7 +88,7 @@ module ActiveRecord
       delegate :add_record, to: :current_state
 
       def batch_touching?
-        states.present?
+        states.present? && !disabled?
       end
 
       # Start batching all touches. When done, apply them. (Unless nested.)
@@ -87,50 +113,54 @@ module ActiveRecord
 
       # Apply the touches that were batched. We're in a transaction already so there's no need to open one.
       def apply_touches
+        current_time = ActiveRecord::Base.current_time_from_proper_timezone
         callbacks_run = Set.new
         all_states = State.new
         while current_state.more_records?
           all_states.merge!(current_state)
           state_records = current_state.records
           current_state.clear_records!
-          state_records.each do |_, records|
-            # Run callbacks to collect more touches (i.e. touch: true for associations)
-            records.each do |record|
-              unless callbacks_run.include?(record)
-                record._run_touch_callbacks
-                callbacks_run.add(record)
-              end
-            end
+          state_records.each do |(_klass, columns), records|
+            soft_touch_records(columns, records, current_time, callbacks_run)
           end
         end
 
         # Sort by class name. Having a consistent order can help mitigate deadlocks.
         sorted_records = all_states.records.keys.sort_by { |k| k.first.name }.map { |k| [k, all_states.records[k]] }.to_h
         sorted_records.each do |(klass, columns), records|
-          touch_records klass, columns, records
+          records.reject!(&:destroyed?)
+          touch_records klass, columns, records, current_time if records.present?
         end
       end
 
-      # Touch the specified records--non-empty set of instances of the same class.
-      def touch_records(klass, columns, records)
-        if columns.present?
-          current_time = records.first.send(:current_time_from_proper_timezone)
-
-          records.each do |record|
-            record.instance_eval do
-              columns.each { |column| write_attribute column, current_time }
+      # Only set new timestamp in memory.
+      # Running callbacks also allows us to collect more touches (i.e. touch: true for associations).
+      def soft_touch_records(columns, records, time, callbacks_run)
+        records.each do |record|
+          record.instance_eval do
+            unless destroyed?
+              columns.each { |column| write_attribute column, time }
               if locking_enabled?
                 self[self.class.locking_column] += 1
                 clear_attribute_change(self.class.locking_column)
               end
               clear_attribute_changes(columns)
             end
+            unless callbacks_run.include?(record)
+              record._run_touch_callbacks
+              callbacks_run.add(record)
+            end
           end
+        end
+      end
 
-          sql = columns.map { |column| "#{klass.connection.quote_column_name(column)} = :current_time" }.join(", ")
+      # Touch the specified records--non-empty set of instances of the same class.
+      def touch_records(klass, columns, records, time)
+        if columns.present?
+          sql = columns.map { |column| "#{klass.connection.quote_column_name(column)} = :time" }.join(", ")
           sql += ", #{klass.locking_column} = #{klass.locking_column} + 1" if klass.locking_enabled?
 
-          klass.unscoped.where(klass.primary_key => records.to_a).update_all([sql, current_time: current_time])
+          klass.unscoped.where(klass.primary_key => records.to_a).update_all([sql, time: time])
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-batch_touching
 version: !ruby/object:Gem::Version
-  version: 1.0.pre.beta
+  version: 1.0.pre.beta4
 platform: ruby
 authors:
 - Brian Morearty
@@ -132,19 +132,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- Gemfile
 - LICENSE
-- activerecord-batch_touching.gemspec
 - lib/activerecord/batch_touching.rb
 - lib/activerecord/batch_touching/state.rb
 - lib/activerecord/batch_touching/version.rb
-- spec/active_record/batch_touching_spec.rb
-- spec/rcov_exclude_list.rb
-- spec/spec_helper.rb
-- spec/support/models.rb
-- spec/support/schema.rb
 homepage: ''
 licenses:
 - MIT
@@ -168,9 +159,4 @@ rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Batch up your ActiveRecord "touch" operations for better performance.
-test_files:
-- spec/active_record/batch_touching_spec.rb
-- spec/rcov_exclude_list.rb
-- spec/spec_helper.rb
-- spec/support/models.rb
-- spec/support/schema.rb
+test_files: []

data/.gitignore

@@ -1,4 +0,0 @@
-.idea
-.ruby-version
-Gemfile.lock
-coverage

data/.rspec

@@ -1,4 +0,0 @@
---color
---tty
---format documentation
---require spec_helper

data/Gemfile

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

data/activerecord-batch_touching.gemspec

@@ -1,30 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'activerecord/batch_touching/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "activerecord-batch_touching"
-  spec.version       = "1.0-beta" # Activerecord::BatchTouching::VERSION
-  spec.authors       = ["Brian Morearty", "Phil Phillips"]
-  spec.email         = ["phil@productplan.com"]
-  spec.summary       = %q{Batch up your ActiveRecord "touch" operations for better performance.}
-  spec.description   = %q{Batch up your ActiveRecord "touch" operations for better performance. All accumulated "touch" calls will be consolidated into as few database round trips as possible.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  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", ">= 6"
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "timecop"
-  spec.add_development_dependency "rspec-rails"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "simplecov-rcov"
-end

data/spec/active_record/batch_touching_spec.rb

@@ -1,369 +0,0 @@
-require 'spec_helper'
-
-describe Activerecord::BatchTouching do
-  let!(:owner) { Owner.create name: "Rosey" }
-  let!(:pet1) { Pet.create(name: "Bones", owner: owner) }
-  let!(:pet2) { Pet.create(name: "Ema", owner: owner) }
-  let!(:car) { Car.create(name: "Ferrari", lock_version: 1) }
-
-  it 'has a version number' do
-    expect(Activerecord::BatchTouching::VERSION).not_to be nil
-  end
-
-  it "touch returns true when not in a batch_touching block" do
-    expect(owner.touch).to equal(true)
-  end
-
-  it "touch returns true in a batch_touching block" do
-    ActiveRecord::Base.transaction do
-      expect(owner.touch).to equal(true)
-    end
-  end
-
-  it "consolidates touches on a single record when inside a transaction" do
-    expect_updates [{ "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        owner.touch
-        owner.touch
-      end
-    end
-  end
-
-  it "calls touch callbacks just once when there are multiple touches" do
-    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
-    ActiveRecord::Base.transaction do
-      owner.touch
-      owner.touch
-    end
-  end
-
-  it 'sets updated_at on the in-memory instance when it eventually touches the record' do
-    original_time = new_time = nil
-
-    Timecop.freeze(2014, 7, 4, 12, 0, 0) do
-      original_time = Time.current
-      owner.touch
-    end
-
-    Timecop.freeze(2014, 7, 10, 12, 0, 0) do
-      new_time = Time.current
-      ActiveRecord::Base.transaction do
-        owner.touch
-        expect(owner.updated_at).to eq(original_time)
-        expect(owner.changed?).to be_falsey
-      end
-    end
-
-    expect(owner.updated_at).to eq(new_time)
-    expect(owner.changed?).to be_falsey
-  end
-
-  it "does not mark the instance as changed when touch is called" do
-    ActiveRecord::Base.transaction do
-      owner.touch
-      expect(owner).not_to be_changed
-    end
-  end
-
-  it "does not mark the instance as changed, even if its lock_version is incremented" do
-    ActiveRecord::Base.transaction do
-      car.touch
-    end
-    expect(car).not_to be_changed
-  end
-
-  it "consolidates touches for all instances in a single table" do
-    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, "owners" => { ids: owner }] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        pet2.touch
-      end
-    end
-  end
-
-  it "does nothing if no_touching is on" do
-    expect(owner).to receive(:_run_touch_callbacks).never
-    expect_updates [] do
-      ActiveRecord::Base.no_touching do
-        ActiveRecord::Base.transaction do
-          owner.touch
-        end
-      end
-    end
-  end
-
-  it "only applies touches for which no_touching is off" do
-    expect(owner).to receive(:_run_touch_callbacks).never
-    expect(pet1).to receive(:_run_touch_callbacks).once.and_call_original
-    expect_updates ["pets" => { ids: pet1 }] do
-      Owner.no_touching do
-        ActiveRecord::Base.transaction do
-          owner.touch
-          pet1.touch
-        end
-      end
-    end
-  end
-
-  it "does not apply nested touches if no_touching was turned on inside batch_touching" do
-    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
-    expect(pet1).to receive(:_run_touch_callbacks).never
-    expect_updates ["owners" => { ids: owner }] do
-      ActiveRecord::Base.transaction do
-        owner.touch
-        ActiveRecord::Base.no_touching do
-          pet1.touch
-        end
-      end
-    end
-  end
-
-  it "can update nonstandard columns" do
-    expect_updates ["owners" => { ids: owner, columns: ["updated_at", "happy_at"] }] do
-      ActiveRecord::Base.transaction do
-        owner.touch :happy_at
-      end
-    end
-  end
-
-  it "treats string column names and symbol column names as the same" do
-    expect_updates ["owners" => { ids: owner, columns: ["updated_at", "happy_at"] }] do
-      ActiveRecord::Base.transaction do
-        owner.touch :happy_at
-        owner.touch "happy_at"
-      end
-    end
-  end
-
-  it "splits up nonstandard column touches and standard column touches" do
-    owner2 = Owner.create name: "Guybrush"
-
-    expect_updates [{ "owners" => { ids: owner, columns: ["updated_at", "happy_at"] } },
-                    { "owners" => { ids: owner2, columns: ["updated_at"] } }] do
-
-      ActiveRecord::Base.transaction do
-        owner.touch :happy_at
-        owner2.touch
-      end
-    end
-  end
-
-  it "can update multiple nonstandard columns of a single record in different calls to touch" do
-    expect_updates [{ "owners" => { ids: owner, columns: ["updated_at", "happy_at"] } },
-                    { "owners" => { ids: owner, columns: ["updated_at", "sad_at"] } }] do
-
-      ActiveRecord::Base.transaction do
-        owner.touch :happy_at
-        owner.touch :sad_at
-      end
-    end
-  end
-
-  it "can update multiple nonstandard columns of a single record in a single call to touch" do
-    expect_updates [{ "owners" => { ids: owner, columns: [ "updated_at", "happy_at", "sad_at"] } }] do
-
-      ActiveRecord::Base.transaction do
-        owner.touch :happy_at, :sad_at
-      end
-    end
-  end
-
-  it "consolidates touch: true touches" do
-    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        pet2.touch
-      end
-    end
-  end
-
-  it "does not touch the owning record via touch: true if it was already touched explicitly" do
-    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
-    expect(pet1).to receive(:_run_touch_callbacks).once.and_call_original
-    expect(pet2).to receive(:_run_touch_callbacks).once.and_call_original
-
-    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        owner.touch
-        pet1.touch
-        pet2.touch
-      end
-    end
-  end
-
-  it "does not consolidate touches when outside a transaction" do
-    expect_updates [{ "owners" => { ids: owner } },
-                    { "owners" => { ids: owner } }] do
-      owner.touch
-      owner.touch
-    end
-  end
-
-  it "nested transactions get consolidated into a single set of touches" do
-    expect(owner).to receive(:_run_touch_callbacks).once.and_call_original
-    expect(pet1).to receive(:_run_touch_callbacks).once.and_call_original
-    expect(pet2).to receive(:_run_touch_callbacks).once.and_call_original
-
-    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        ActiveRecord::Base.transaction do
-          pet2.touch
-        end
-      end
-    end
-  end
-
-  it "rolling back from a nested transaction without :requires_new touches the records in the inner transaction" do
-    expect_updates [{ "pets" => { ids: [pet1, pet2] } }, { "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        ActiveRecord::Base.transaction do
-          pet2.touch
-          raise ActiveRecord::Rollback
-        end
-      end
-    end
-  end
-
-  it "rolling back from a nested transaction with :requires_new does not touch the records in the inner transaction" do
-    expect_updates [{ "pets" => { ids: pet1 } }, { "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        ActiveRecord::Base.transaction(requires_new: true) do
-          pet2.touch
-          raise ActiveRecord::Rollback
-        end
-      end
-    end
-  end
-
-  it "touching a record in an outer and inner new transaction, then rolling back the inner one, still touches the record" do
-    expect_updates [{ "pets" => { ids: pet1 } }, { "owners" => { ids: owner } }] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        ActiveRecord::Base.transaction(requires_new: true) do
-          pet1.touch
-          raise ActiveRecord::Rollback
-        end
-      end
-    end
-  end
-
-  it "rolling back from an outer transaction does not touch any records" do
-    expect_updates [] do
-      ActiveRecord::Base.transaction do
-        pet1.touch
-        ActiveRecord::Base.transaction do
-          pet2.touch :neutered_at
-        end
-        raise ActiveRecord::Rollback
-      end
-    end
-  end
-
-  it "consolidates touch: :column_name touches" do
-    pet_klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Pet'; end
-      belongs_to :owner, :touch => :happy_at
-      after_touch :after_touch_callback
-      def after_touch_callback; end
-    end
-
-    pet = pet_klass.first
-    owner = pet.owner
-
-    expect_updates [{ "owners" => { ids: owner, columns: ["updated_at", "happy_at"] } }, { "pets" => { ids: pet } }] do
-      ActiveRecord::Base.transaction do
-        pet.touch
-        pet.touch
-      end
-    end
-  end
-
-  it "keeps iterating as long as after_touch keeps causing more records to be touched" do
-    pet_klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Pet'; end
-      belongs_to :owner
-
-      # Touch the owner in after_touch instead of using touch: true
-      after_touch :touch_owner
-      def touch_owner; owner.touch; end
-    end
-
-    pet = pet_klass.first
-    owner = pet.owner
-
-    expect_updates [{ "owners" => { ids: owner } }, { "pets" => { ids: pet } }] do
-      ActiveRecord::Base.transaction do
-        pet.touch
-      end
-    end
-  end
-
-  it "increments the optimistic lock column in memory and in the DB" do
-    car1 = Car.create(name: "Ferrari", lock_version: 1)
-    car2 = Car.create(name: "Lambo", lock_version: 2)
-
-    ActiveRecord::Base.transaction do
-      car1.touch
-      car2.touch
-    end
-
-    expect(car1.lock_version).to equal(2)
-    expect(car2.lock_version).to equal(3)
-
-    expect(car1.reload.lock_version).to equal(2)
-    expect(car2.reload.lock_version).to equal(3)
-  end
-
-  private
-
-  def expect_updates(tables_ids_and_columns)
-    expected_sql = expected_sql_for(tables_ids_and_columns)
-    expect(ActiveRecord::Base.connection).to receive(:update).exactly(expected_sql.length).times do |stmt, _, _|
-      if stmt.to_sql =~ /UPDATE /i
-        index = expected_sql.index { |expected_stmt| stmt.to_sql =~ expected_stmt }
-        expect(index).to be, "An unexpected touch occurred: #{stmt.to_sql}"
-        expected_sql.delete_at(index)
-      end
-    end
-
-    yield
-
-    expect(expected_sql).to be_empty, "Some of the expected updates were not executed."
-  end
-
-  # Creates an array of regular expressions to match the SQL statements that we expect
-  # to execute.
-  #
-  # Each element in the tables_ids_and_columns array is in this form:
-  #
-  #   { "table_name" => { ids: id_or_array_of_ids, columns: column_name_or_array } }
-  #
-  # 'columns' is optional. If it's missing it is assumed that "updated_at" is the only
-  # column that gets touched.
-  def expected_sql_for(tables_ids_and_columns)
-    tables_ids_and_columns.map do |entry|
-      entry.map do |table, options|
-        ids = Array.wrap(options[:ids])
-        columns = Array.wrap(options[:columns]).presence || ["updated_at"]
-        columns = columns.sort
-        Regexp.new(touch_sql(table, columns, ids))
-      end
-    end.flatten
-  end
-
-  # in:  array of records or record ids
-  # out: "( = 1|= \?|= \$1)" or " IN (1, 2)"
-  #
-  # In some cases, such as SQLite3 when outside a transaction, the logged SQL uses ? instead of record ids.
-  def ids_sql(ids)
-    ids = ids.map { |id| id.class.respond_to?(:primary_key) ? id.send(id.class.primary_key) : id }
-    ids.length > 1 ? %{ IN \\(#{Array.new(ids.length, '\?').join(", ")}\\)} : %{( = #{ids.first}|= \\?|= \\$1)}
-  end
-
-  def touch_sql(table, columns, ids)
-    %{UPDATE \\"#{table}"\\ SET #{columns.map { |column| %{\\"#{column}\\" =.+} }.join(", ") } .+#{ids_sql(ids)}\\Z}
-  end
-end

data/spec/rcov_exclude_list.rb

@@ -1,3 +0,0 @@
-@exclude_list = [
-  'spec/**/*.rb'
-]

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-if ENV["COVERAGE"]
-  require_relative 'rcov_exclude_list.rb'
-  exlist = Dir.glob(@exclude_list)
-  require 'simplecov'
-  require 'simplecov-rcov'
-  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
-  SimpleCov.start do
-    exlist.each do |p|
-      add_filter p
-    end
-  end
-end
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'active_record'
-require 'activerecord/batch_touching'
-require 'timecop'
-
-ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
-
-load File.dirname(__FILE__) + '/support/schema.rb'
-require File.dirname(__FILE__) + '/support/models.rb'

data/spec/support/models.rb

@@ -1,9 +0,0 @@
-class Owner < ActiveRecord::Base
-  has_many :pets, inverse_of: :owner
-end
-
-class Pet < ActiveRecord::Base
-  belongs_to :owner, touch: true, inverse_of: :pets
-end
-
-class Car < ActiveRecord::Base; end

data/spec/support/schema.rb

@@ -1,27 +0,0 @@
-ActiveRecord::Schema.define do
-  self.verbose = false
-
-  create_table :owners, :force => true do |t|
-    t.string :name
-
-    t.timestamps
-    t.datetime :happy_at
-    t.datetime :sad_at
-  end
-
-  create_table :pets, :force => true do |t|
-    t.string :name
-    t.integer :owner_id
-    t.datetime :neutered_at
-
-    t.timestamps
-  end
-
-  create_table :cars, force: true do |t|
-    t.string :name
-    t.column :lock_version, :integer, null: false, default: 0
-
-    t.timestamps
-  end
-
-end