activerecord5_delay_touching 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ade7a8b8641da8a585a1428d7912234df0c15d4
+  data.tar.gz: 52b4ea7dd787480d6ca58d8bbfd19d4ff550a9eb
+SHA512:
+  metadata.gz: 56a9977a19d7db5a7a2f152ca0e0c5099c55129f612ba05e1b864968d76f7fc1f48d91d386abba9e1256cec2f413d60c3f7221ab326ed3daaf00e1e84a30c887
+  data.tar.gz: e8058a3c8423fbb51153e9e0f70d6b7ad774d95f691112eac906e7c3adb8ec79a43b97e4f680f16f9ce5447ad2874ed07b2ae03908272a01f2c8d85b45610c17

data/.gitignore

@@ -0,0 +1,26 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version
+coverage/
+results.xml

data/.rspec

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 GoDaddy
+
+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,110 @@
+# Activerecord::DelayTouching
+
+> **Note:** this version requires ActiveRecord 4.2 or higher. To use ActiveRecord 3.2 through 4.1, use the branch https://github.com/Kenneth-KT/activerecord5_delay_touching/tree/pre-activerecord-4.2.
+
+Batch up your ActiveRecord "touch" operations for better performance.
+
+When you want to invalidate a cache in Rails, you use `touch: true`. But when
+you modify a bunch of records that all `belong_to` the same owning record, that record
+will be touched N times. It's incredibly slow.
+
+With this gem, all `touch` operations are consolidated into as few database
+round-trips as possible. Instead of N touches you get 1 touch.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord5_delay_touching'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself:
+
+    $ gem install activerecord5_delay_touching
+
+## Usage
+
+The setup:
+
+    class Person < ActiveRecord::Base
+      has_many :pets
+      accepts_nested_attributes_for :pets
+    end
+    
+    class Pet < ActiveRecord::Base
+      belongs_to :person, touch: true
+    end
+    
+Without `delay_touching`, this simple `update` in the controller calls
+`@person.touch` N times, where N is the number of pets that were updated
+via nested attributes. That's N-1 unnecessary round-trips to the database:
+
+    class PeopleController < ApplicationController
+      def update
+        ...
+        #
+        @person.update(person_params)
+        ...
+      end
+    end
+    
+    # SQL (0.1ms)  UPDATE "people" SET "updated_at" = '2014-07-09 19:48:07.137158' WHERE "people"."id" = 1
+    # SQL (0.1ms)  UPDATE "people" SET "updated_at" = '2014-07-09 19:48:07.138457' WHERE "people"."id" = 1
+    # SQL (0.1ms)  UPDATE "people" SET "updated_at" = '2014-07-09 19:48:07.140088' WHERE "people"."id" = 1
+
+With `delay_touching`, @person is touched only once:
+
+    ActiveRecord::Base.delay_touching do
+      @person.update(person_params)
+    end
+
+    # SQL (0.1ms)  UPDATE "people" SET "updated_at" = '2014-07-09 19:48:07.140088' WHERE "people"."id" = 1
+
+## Consolidates Touches Per Table
+
+In the following example, a person gives his pet to another person. ActiveRecord
+automatically touches the old person and the new person.  With `delay_touching`,
+this will only make a *single* round-trip to the database, setting `updated_at`
+for all Person records in a single SQL UPDATE statement. Not a big deal when there are
+only two touches, but when you're updating records en masse and have a cascade
+of hundreds touches, it really is a big deal.
+
+    class Pet < ActiveRecord::Base
+      belongs_to :person, touch: true
+
+      def give(to_person)
+        ActiveRecord::Base.delay_touching do
+          self.person = to_person
+          save! # touches old person and new person in a single SQL UPDATE.
+        end
+      end
+    end
+
+## Cascading Touches
+
+When `delay_touch` runs through and touches everything, it captures additional
+`touch` calls that might be called as side-effects. (E.g., in `after_touch`
+handlers.) Then it makes a second pass, batching up those touches as well.
+
+It keeps doing this until there are no more touches, or until the sun swallows
+up the earth. Whichever comes first.
+
+## Gotchas
+
+Things to note:
+
+  * `after_touch` callbacks are still fired for every instance, but not until the block is exited. 
+    And they won't happen in the same order as they would if you weren't batching up your touches.
+  * If you call person1.touch and then person2.touch, and they are two separate instances
+    with the same id, only person1's `after_touch` handler will be called.
+
+## Contributing
+
+1. Fork it ( https://github.com/Kenneth-KT/activerecord5_delay_touching/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rspec/core"
+require "rspec/core/rake_task"
+
+Rake::Task["spec"].clear
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.fail_on_error = false
+  t.rspec_opts = %w[-f JUnit -o results.xml]
+end
+
+desc "Run RSpec with code coverage"
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task["spec"].execute
+end
+task :default => :spec

data/activerecord5_delay_touching.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord/delay_touching/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord5_delay_touching"
+  spec.version       = Activerecord::DelayTouching::VERSION
+  spec.authors       = ["GoDaddy P&C Commerce", "Brian Morearty"]
+  spec.email         = ["nemo-engg@godaddy.com", "brian@morearty.org"]
+  spec.summary       = %q{Batch up your ActiveRecord "touch" operations for better performance.}
+  spec.description   = %q{Batch up your ActiveRecord "touch" operations for better performance. ActiveRecord::Base.delay_touching do ... end. When "end" is reached, 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", ">= 4.2", "< 5.3"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "rspec-rails", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-rcov"
+  spec.add_development_dependency "yarjuf"
+end

data/lib/activerecord/delay_touching.rb

@@ -0,0 +1,123 @@
+require "activerecord/delay_touching/version"
+require "activerecord/delay_touching/state"
+
+module ActiveRecord
+  module DelayTouching
+    extend ActiveSupport::Concern
+
+    # Override ActiveRecord::Base#touch.
+    if ActiveRecord::VERSION::MAJOR >= 5
+      def touch(*names, time: nil)
+        names = self.class.send(:timestamp_attributes_for_update_in_model) if names.empty?
+        DelayTouching.handle_touch(self, names) || super
+      end
+    else
+      def touch(*names)
+        DelayTouching.handle_touch(self, names) || super
+      end
+    end
+
+    # These get added as class methods to ActiveRecord::Base.
+    module ClassMethods
+      # Lets you batch up your `touch` calls for the duration of a block.
+      #
+      # ==== Examples
+      #
+      #   # Touches Person.first once, not twice, when the block exits.
+      #   ActiveRecord::Base.delay_touching do
+      #     Person.first.touch
+      #     Person.first.touch
+      #   end
+      #
+      def delay_touching(&block)
+        DelayTouching.call &block
+      end
+
+      # Are we currently executing in a delay_touching block?
+      def delay_touching?
+        DelayTouching.state.nesting > 0
+      end
+    end
+
+    def self.state
+      Thread.current[:delay_touching_state] ||= State.new
+    end
+
+    class << self
+      delegate :add_record, to: :state
+    end
+
+    def self.handle_touch(record, names)
+      if record.class.delay_touching? && !record.try(:no_touching?)
+        add_record(record, *names)
+        true
+      end
+    end
+
+    # Start delaying all touches. When done, apply them. (Unless nested.)
+    def self.call
+      state.nesting += 1
+      begin
+        yield
+      ensure
+        apply if state.nesting == 1
+      end
+    ensure
+      # Decrement nesting even if `apply` raised an error.
+      state.nesting -= 1
+    end
+
+    # Apply the touches that were delayed.
+    def self.apply
+      begin
+        ActiveRecord::Base.transaction do
+          state.records_by_attrs_and_class.each do |attr, classes_and_records|
+            classes_and_records.each do |klass, records|
+              touch_records attr, klass, records
+            end
+          end
+        end
+      end while state.more_records?
+    ensure
+      state.clear_records
+    end
+
+    # Touch the specified records--non-empty set of instances of the same class.
+    def self.touch_records(attr, klass, records)
+      attributes = records.first.send(:timestamp_attributes_for_update_in_model)
+      attributes << attr if attr
+
+      if attributes.present?
+        current_time = records.first.send(:current_time_from_proper_timezone)
+        changes = {}
+
+        attributes.each do |column|
+          column = column.to_s
+          changes[column] = current_time
+          records.each do |record|
+            # Don't bother if destroyed or not-saved
+            next unless record.persisted?
+            record.send(:write_attribute, column, current_time)
+            clear_attribute_changes(record, changes.keys)
+          end
+        end
+
+        klass.unscoped.where(klass.primary_key => records).update_all(changes)
+      end
+      state.updated attr, records
+      records.each { |record| record.run_callbacks(:touch) }
+    end
+
+    if ActiveRecord::VERSION::MAJOR >= 5
+      def self.clear_attribute_changes(record, attr_names)
+        record.clear_attribute_changes(attr_names)
+      end
+    else
+      def self.clear_attribute_changes(record, attr_names)
+        record.instance_variable_get('@changed_attributes').except!(*attr_names)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include ActiveRecord::DelayTouching

data/lib/activerecord/delay_touching/state.rb

@@ -0,0 +1,58 @@
+require "activerecord/delay_touching/version"
+
+module ActiveRecord
+  module DelayTouching
+
+    # Tracking of the touch state. This class has no class-level data, so you can
+    # store per-thread instances in thread-local variables.
+    class State
+      attr_accessor :nesting
+
+      def initialize
+        @records = Hash.new { Set.new }
+        @already_updated_records = Hash.new { Set.new }
+        @nesting = 0
+      end
+
+      def updated(attr, records)
+        @records[attr].subtract records
+        @records.delete attr if @records[attr].empty?
+        @already_updated_records[attr] += records
+      end
+
+      # Return the records grouped by the attributes that were touched, and by class:
+      # [
+      #   [
+      #     nil, { Person => [ person1, person2 ], Pet => [ pet1 ] }
+      #   ],
+      #   [
+      #     :neutered_at, { Pet => [ pet1 ] }
+      #   ],
+      # ]
+      def records_by_attrs_and_class
+        @records.map { |attrs, records| [attrs, records.group_by(&:class)] }
+      end
+
+      # There are more records as long as there is at least one record that is persisted
+      def more_records?
+        @records.each do |_, set|
+          set.each { |record| return true if record.persisted? } # will shortcut on first persisted record found
+        end
+
+        false # no persisted records found, so no more records to process
+      end
+
+      def add_record(record, *columns)
+        columns << nil if columns.empty? #if no arguments are passed, we will use nil to infer default column
+        columns.each do |column|
+          @records[column] += [ record ] unless @already_updated_records[column].include?(record)
+        end
+      end
+
+      def clear_records
+        @records.clear
+        @already_updated_records.clear
+      end
+    end
+  end
+end

data/lib/activerecord/delay_touching/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module DelayTouching
+    VERSION = "1.1.1"
+  end
+end

data/lib/activerecord5_delay_touching.rb

@@ -0,0 +1 @@
+require "activerecord/delay_touching"

data/spec/activerecord5/delay_touching_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe Activerecord::DelayTouching do
+  let(:person) { Person.create name: "Rosey" }
+  let(:pet1) { Pet.create(name: "Bones") }
+  let(:pet2) { Pet.create(name: "Ema") }
+
+  it 'has a version number' do
+    expect(Activerecord::DelayTouching::VERSION).not_to be nil
+  end
+
+  it 'touch returns true' do
+    ActiveRecord::Base.delay_touching do
+      expect(person.touch).to eq(true)
+    end
+  end
+
+  it 'consolidates touches on a single record' do
+    expect_updates ["people"] do
+      ActiveRecord::Base.delay_touching do
+        person.touch
+        person.touch
+      end
+    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
+      person.touch
+    end
+
+    Timecop.freeze(2014, 7, 10, 12, 0, 0) do
+      new_time = Time.current
+      ActiveRecord::Base.delay_touching do
+        person.touch
+        expect(person.updated_at).to eq(original_time)
+        expect(person.changed?).to be_falsey
+      end
+    end
+
+    expect(person.updated_at).to eq(new_time)
+    expect(person.changed?).to be_falsey
+  end
+
+  it 'does not mark the instance as changed when touch is called' do
+    ActiveRecord::Base.delay_touching do
+      person.touch
+      expect(person).not_to be_changed
+    end
+  end
+
+  it 'consolidates touches for all instances in a single table' do
+    expect_updates ["pets"] do
+      ActiveRecord::Base.delay_touching do
+        pet1.touch
+        pet2.touch
+      end
+    end
+  end
+
+  it 'does nothing if no_touching is on' do
+    if ActiveRecord::Base.respond_to?(:no_touching)
+      expect_updates [] do
+        ActiveRecord::Base.no_touching do
+          ActiveRecord::Base.delay_touching do
+            person.touch
+          end
+        end
+      end
+    end
+  end
+
+  it 'only applies touches for which no_touching is off' do
+    if Person.respond_to?(:no_touching)
+      expect_updates ["pets"] do
+        Person.no_touching do
+          ActiveRecord::Base.delay_touching do
+            person.touch
+            pet1.touch
+          end
+        end
+      end
+    end
+  end
+
+  it 'does not apply nested touches if no_touching was turned on inside delay_touching' do
+    if ActiveRecord::Base.respond_to?(:no_touching)
+      expect_updates [ "people" ] do
+        ActiveRecord::Base.delay_touching do
+          person.touch
+          ActiveRecord::Base.no_touching do
+            pet1.touch
+          end
+        end
+      end
+    end
+  end
+
+  it 'can update nonstandard columns' do
+    expect_updates [ "pets" => [ "updated_at", "neutered_at" ] ] do
+      ActiveRecord::Base.delay_touching do
+        pet1.touch :neutered_at
+      end
+    end
+  end
+
+  it 'splits up nonstandard column touches and standard column touches' do
+    expect_updates [ { "pets" => [ "updated_at", "neutered_at" ]  }, { "pets" => [ "updated_at" ] } ] do
+      ActiveRecord::Base.delay_touching do
+        pet1.touch :neutered_at
+        pet2.touch
+      end
+    end
+  end
+
+  it 'can update multiple nonstandard columns of a single record in different calls to touch' do
+    expect_updates [ { "pets" => [ "updated_at", "neutered_at" ] }, { "pets" => [ "updated_at", "fed_at" ] } ] do
+      ActiveRecord::Base.delay_touching do
+        pet1.touch :neutered_at
+        pet1.touch :fed_at
+      end
+    end
+  end
+
+  context 'touch: true' do
+    before do
+      person.pets << pet1
+      person.pets << pet2
+    end
+
+    it 'consolidates touch: true touches' do
+      expect_updates [ "pets", "people" ] do
+        ActiveRecord::Base.delay_touching 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_updates [ "pets", "people" ] do
+        ActiveRecord::Base.delay_touching do
+          person.touch
+          pet1.touch
+          pet2.touch
+        end
+      end
+    end
+  end
+
+  context 'dependent deletes' do
+
+    let(:post) { Post.create! }
+    let(:user) { User.create! }
+    let(:comment) { Comment.create! }
+
+    before do
+      post.comments << comment
+      user.comments << comment
+    end
+
+    it 'does not attempt to touch deleted records' do
+      expect do
+        ActiveRecord::Base.delay_touching do
+          post.destroy
+        end
+      end.not_to raise_error
+      expect(post.destroyed?).to eq true
+    end
+
+  end
+
+  context 'persistence fails and rolls back transaction' do
+
+    it 'does not infinitely loop' do
+      updates = 0
+      allow(ActiveRecord::Base.connection).to receive(:update).and_wrap_original do |m, *args|
+        updates = updates + 1
+        raise StandardError, 'Too many updates - likely infinite loop detected' if updates > 1
+
+        m.call(*args)
+      end
+
+      ActiveRecord::Base.delay_touching do
+        ActiveRecord::Base.transaction do
+          # write and touch any new record
+          record = Post.create!
+          record.touch
+          raise ActiveRecord::Rollback
+        end
+      end
+
+    end
+
+  end
+
+  def expect_updates(tables)
+    expected_sql = tables.map do |entry|
+      if entry.kind_of?(Hash)
+        entry.map do |table, columns|
+          Regexp.new(%Q{UPDATE "#{table}" SET #{columns.map { |column| %Q{"#{column}" =.+} }.join(", ") } })
+        end
+      else
+        Regexp.new(%Q{UPDATE "#{entry}" SET "updated_at" = })
+      end
+    end.flatten
+    expect(ActiveRecord::Base.connection).to receive(:update).exactly(expected_sql.length).times do |stmt, _, _|
+      index = expected_sql.index { |sql| stmt.to_sql =~ sql}
+      expect(index).to be, "An unexpected touch occurred: #{stmt.to_sql}"
+      expected_sql.delete_at(index)
+    end
+
+    yield
+
+    expect(expected_sql).to be_empty, "Some of the expected updates were not executed."
+  end
+end

data/spec/rcov_exclude_list.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'yarjuf'
+
+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/delay_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

@@ -0,0 +1,20 @@
+class Person < ActiveRecord::Base
+  has_many :pets, inverse_of: :person
+end
+
+class Pet < ActiveRecord::Base
+  belongs_to :person, touch: true, inverse_of: :pets
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments, dependent: :destroy
+end
+
+class User < ActiveRecord::Base
+  has_many :comments, dependent: :destroy
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post, touch: true
+  belongs_to :user, touch: true
+end

data/spec/support/schema.rb

@@ -0,0 +1,33 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :people, :force => true do |t|
+    t.string :name
+
+    t.timestamps
+  end
+
+  create_table :pets, :force => true do |t|
+    t.string :name
+    t.integer :person_id
+    t.datetime :neutered_at
+    t.datetime :fed_at
+
+    t.timestamps
+  end
+
+  create_table :posts, force: true do |t|
+    t.timestamps null: false
+  end
+
+  create_table :users, force: true do |t|
+    t.timestamps null: false
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :post_id
+    t.integer :user_id
+    t.timestamps null: false
+  end
+
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: activerecord5_delay_touching
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- GoDaddy P&C Commerce
+- Brian Morearty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yarjuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Batch up your ActiveRecord "touch" operations for better performance.
+  ActiveRecord::Base.delay_touching do ... end. When "end" is reached, all accumulated
+  "touch" calls will be consolidated into as few database round trips as possible.
+email:
+- nemo-engg@godaddy.com
+- brian@morearty.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord5_delay_touching.gemspec
+- lib/activerecord/delay_touching.rb
+- lib/activerecord/delay_touching/state.rb
+- lib/activerecord/delay_touching/version.rb
+- lib/activerecord5_delay_touching.rb
+- spec/activerecord5/delay_touching_spec.rb
+- spec/rcov_exclude_list.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+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.6.14
+signing_key: 
+specification_version: 4
+summary: Batch up your ActiveRecord "touch" operations for better performance.
+test_files:
+- spec/activerecord5/delay_touching_spec.rb
+- spec/rcov_exclude_list.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb