counter-cache 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 381fdac0060611f59b5314096aa953310c927a98
-  data.tar.gz: 94cfd0f2f7f91c8e7fd3e6c2f2579d26fee90904
+  metadata.gz: 005de7af8ad6de2ac4db333a51a0b69037b415da
+  data.tar.gz: 82e11a2ff62767df0275d60e12ef8f6208f76dc3
 SHA512:
-  metadata.gz: 41ac6baff5ade8a503c71244efcbfd584982e0ec9ea00bde813c0797100f30044e9304c922e3f20afbab0a3e82b3c5e4c9efb5cc90125cadab6d52901b85e0b8
-  data.tar.gz: aa2e8b95531190a0cddcc33d5f88f4a7a332a2646f8ff39784db5ecaea567e431a6fb7af23ab06375172b613d6f28c24081cc6f5b9b043bd7f65bf7066cbd041
+  metadata.gz: a19850cde42e9e3d8413bc8d2b0f8ab134736c16df4171c788c2cc611363429d6830191d29027084bd93d2466d64dcda731949d2313d0f07311db87faa96dbce
+  data.tar.gz: e90d15bae6c2de8781dcb792e90f9b7f1e40fe4fdbefa7d83b9a5bc91515dbc01ced62ff68f3f3450716f0e23319e845a38767528a8e5b3bd221bcbd72da8460

data/.gitignore

@@ -7,7 +7,6 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
-doc/
 lib/bundler/man
 pkg
 rdoc

data/.travis.yml

@@ -1,10 +1,10 @@
-language: ruby
 rvm:
-  - 2.1.1
-  - 2.1.0
-  - 2.0.0
-  - 1.9.3
+  - "1.9.3"
+  - "2.1.1"
+gemfile:
+  - gemfiles/activerecord_3.gemfile
+  - gemfiles/activerecord_4.0.gemfile
+  - gemfiles/activerecord_4.1.gemfile
 notifications:
-  email:
-    on_success: never
-webhooks: "http://ci.wanelo.com/projects/2f4c3438-a0bc-434e-a9fb-30c0c335b432/status"
+  email: false
+  webhooks: "http://ci.wanelo.com/projects/d6108a07-a333-487a-97ed-0df78d8464c0/status"

data/Appraisals

@@ -0,0 +1,11 @@
+appraise "activerecord-3" do
+  gem "activerecord", "~> 3.2.19"
+end
+
+appraise "activerecord-4.0" do
+  gem "activerecord", "~> 4.0.8"
+end
+
+appraise "activerecord-4.1" do
+  gem "activerecord", "~> 4.1.4"
+end

data/README.md

@@ -1,6 +1,82 @@
 # Counter::Cache
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/wanelo/counter-cache.svg?branch=master)](https://travis-ci.org/wanelo/counter-cache)
+
+Counting things is hard, counting them at scale is even harder, so control when things are counted. 
+
+[Rails Counter Caches](http://railscasts.com/episodes/23-counter-cache-column) are a convenient way to keep counters on
+models that have many children. Without them, you always do live counts, which do not scale. But at high scale, Rails
+counter caches create update contention on singe models, especially for social sites where any single model might become
+extremely popular. Many web requests trying to update the same row creates database deadlocks and kills performance due
+to locking and an uncontrollable increase in iops.
+
+This library provides all the benefits of rails counter cache, without the penalty of the contention on updates,
+by serializing, buffering, and delaying updates via a queue. Counts becoming slightly less realtime, but with a guarantee that
+single models will never be updated more than once in certain time periods.
+
+![Counter Cache Flow](doc/counter-cache-flow.png)
+
+By default, a Buffer Counter is used which implements two modes of counting. The two modes are deferred and recalculation.
+
+IMPORTANT: If Sidekiq is to be used as the delayed job framework, using `sidekiq-unique-jobs` is essential: https://github.com/mhenrixon/sidekiq-unique-jobs
+
+### Mode: Deferred
+
+Initial mode that is used to provide roughly realtime counters.
+
+This mode is meant to provide very reasonably up to date counters using values buffered into Redis, without asking the database
+for the count at all. An example of how this works is described:
+
+Scenario: User has many posts. We want to keep track of the number of posts on the user model (posts_count column).
+
+When a post is created:
+
+1. Increment a key in Redis that corresponds to the field and user that relates to the post.
+2. Enqueue a delayed job that will later reconcile the counter column based on the key in redis.
+3. When the job runs, it picks up the value from redis (which can be zero or more) and adds the value to user.posts_count
+   column on the associated model.
+
+```ruby
+  user = User.find_by_id(100)
+  user.posts_count # 10
+  user.posts.create(...) # => Job is enqueued
+  user.posts.create(...) # => Job is already enqueued
+
+  # come back later (after a delay)
+  user = User.find_by_id(100)
+  user.posts_count # 12
+```
+
+### Mode: Recalculation
+
+Runs later and ensures values are completely up to date.
+
+This mode is used to compensate for transient errors that may cause the deferred counters to drift from the actual
+values. The exact reasons this happens are undefined, redis could hang, go away, the universe could skip ahead in time,
+who knows.
+
+Using the same scenario as above:
+
+Scenario: User has many posts. We want to keep track of the number of posts on the user model (posts_count column).
+
+1. Enqueue a job that is delayed by many hours (customizable)
+2. When the job runs, run a full count query to find the true count from the database and save the value to the database.
+
+```ruby
+  user = User.find_by_id(100)
+  user.posts_count # 10
+  user.posts.create(...)
+  user.posts.create(...)
+
+  # redis crashes, world explodes, etc.. we miss on deferred update.
+
+  user = User.find_by_id(100)
+  user.posts_count # 11, due to only one deferred update having run.
+
+  # come back later in a couple hours
+  user = User.find_by_id(100)
+  user.posts_count # 12
+```
 
 ## Installation
 
@@ -18,7 +94,163 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Counter caches are configured on the models from the perspective of the child model to the parent that contains the counter.
+
+#### Basic Counter with recalculation:
+
+```ruby
+class Post
+  include Counter::Cache
+
+  counter_cache_on column: :posts_count, # users.posts_count
+                   relation: :user,
+                   relation_class_name: "User",
+                   method: :calculate_posts_count, # This is a method on the user.
+end
+```
+
+#### To control when recalculation happens:
+
+```ruby
+class Post
+  include Counter::Cache
+
+  counter_cache_on column: :posts_count, # users.posts_count
+                   relation: :user,
+                   relation_class_name: "User",
+                   method: :calculate_posts_count, # This is a method on the user.
+                   recalculation: true|false, # whether to ever recalculate this counter.
+                   recalculation_delay: 10.seconds # Only a hard value that defines when to perform a full recalculation.
+end
+```
+
+#### To control when the deferred job runs:
+
+```ruby
+class Post
+  include Counter::Cache
+
+  counter_cache_on column: :posts_count, # users.posts_count
+                   relation: :user,
+                   relation_class_name: "User",
+                   method: :calculate_posts_count, # This is a method on the user.
+                   wait: 10.seconds # This can be a hard value
+
+  counter_cache_on column: :posts_count, # users.posts_count
+                   relation: :user,
+                   relation_class_name: "User",
+                   method: :calculate_posts_count, # This is a method on the user.
+                   wait: ->(user) { user.posts_count * 10 } # .. or a proc, in this case, the more posts a user has, the less frequently it will be updated.
+end
+```
+
+#### To control if an update should even happen:
+
+```ruby
+class Post
+  include Counter::Cache
+
+  counter_cache_on column: :posts_count, # users.posts_count
+                   relation: :user,
+                   relation_class_name: "User",
+                   method: :calculate_posts_count, # This is a method on the user.
+                   if: ->(post) { post.public? ? false : true }
+end
+```
+
+#### Polymorphism (because YAY)
+
+Setting `polymorphic: true`, will ask ActiveRecord what the class is (User, Store), based on followee_type, and update
+the appropriate model. So if a user is followed, then that users followers_count will increment.
+
+```ruby
+class User
+  attr_accessible :followers_count
+end
+
+class Store
+  attr_accessible :followers_count
+end
+
+class Follow
+  attr_accessible :user_id, :followee_id, :followee_type
+
+  belongs_to :followee, polymorphic: true
+
+  include Counter::Cache
+
+  counter_cache_on column: :followers_count,
+                   relation: :followee,
+                   polymorphic: true
+end
+```
+
+## Configuration
+
+In an initializer such as `config/initializers/counter_cache.rb`, write the configuration as:
+
+```ruby
+Counter::Cache.configure do |c|
+  c.default_worker_adapter = MyCustomWorkAdapter
+  c.recalculation_delay    = 6.hours # Default delay for recalculations
+  c.redis_pool             = Redis.new
+  c.counting_data_store    = MyCustomDataStore # Default is Counter::Cache::Redis
+end
+```
+
+### default_worker_adapter
+
+The worker adapter allows you to control how jobs are delayed/enqueued for later execution. Three options are passed:
+
+ - delay: This is the delay in seconds that the execution should be delayed. Can be ignored or adjusted. We pass this to
+   sidekiq.
+ - base_class: This is the class name of the source object.
+ - options: This will be a hash of options that should be passed to the instance of the counter.
+
+An example of a dummy adapter is like so:
+
+```ruby
+class TestWorkerAdapter
+  def enqueue(delay, base_class, options)
+    options[:source_object_class_name] = base_class.constantize
+    counter_class = options[:counter].constantize # options[:counter] is the class name of the counter that called the adapter.
+    counter = counter_class.new(nil, options)
+    counter.save!
+  end
+end
+```
+
+An example of a dummy adapter that uses Sidekiq is like so:
+
+```ruby
+class CounterWorker
+  include Sidekiq::Worker
+
+  def perform(base_class, options)
+    options.symbolize_keys! # From ActiveSupport, Sidekiq looses symbol information from hashes.
+    options[:source_object_class_name] = base_class.constantize
+    counter_class = options[:counter].constantize # options[:counter] is the class name of the counter that called the adapter.
+    counter = counter_class.new(nil, options)
+    counter.save!
+  end
+
+  def self.enqueue(delay, base_class, options)
+    perform_in(delay, base_class, options)
+  end
+end
+```
+
+### recalculation_delay
+
+This should be set to the default delay for recalculations, in seconds.
+
+### redis_pool
+
+This can either be a single redis connection or a ConnectionPool instance (https://github.com/mperham/connection_pool).
+
+### counting_data_store
+
+This defaults to Counter::Cache::Redis but can be set to anything. The Redis store describes what the API would be.
 
 ## Contributing
 
@@ -27,3 +259,15 @@ TODO: Write usage instructions here
 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
+
+### Running specs:
+
+Appraisal is used to test against multiple versions of activerecord. 3.2, 4.0, and 4.1 are currently supported.
+
+To install dependencies:
+
+    $ bundle exec appraisal install
+
+To run specs across versions:
+
+    $ bundle exec appraisal rspec

data/counter-cache.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "activerecord", ">= 3.0"
 
+  spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ">= 3.0"

data/gemfiles/activerecord_3.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 3.2.19"
+
+gemspec :path => "../"

data/gemfiles/activerecord_3.gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: ../
+  specs:
+    counter-cache (0.0.2)
+      activerecord (>= 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+    activerecord (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.19)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    appraisal (1.0.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    fakeredis (0.5.0)
+      redis (~> 3.0)
+    ffi (1.9.3)
+    formatador (0.2.5)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.3.1)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    i18n (0.6.11)
+    listen (2.7.9)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    multi_json (1.10.1)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    redis (3.1.0)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.3)
+    slop (3.6.0)
+    sqlite3 (1.3.9)
+    thor (0.19.1)
+    timers (1.1.0)
+    tzinfo (0.3.39)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.2.19)
+  appraisal
+  bundler (~> 1.6)
+  counter-cache!
+  fakeredis
+  guard
+  guard-rspec
+  rake
+  rspec (>= 3.0)
+  sqlite3

data/gemfiles/activerecord_4.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.0.8"
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.0.gemfile.lock

@@ -0,0 +1,98 @@
+PATH
+  remote: ../
+  specs:
+    counter-cache (0.0.2)
+      activerecord (>= 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.0.8)
+      activesupport (= 4.0.8)
+      builder (~> 3.1.0)
+    activerecord (4.0.8)
+      activemodel (= 4.0.8)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.8)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.8)
+      i18n (~> 0.6, >= 0.6.9)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    appraisal (1.0.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    arel (4.0.2)
+    builder (3.1.4)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    fakeredis (0.5.0)
+      redis (~> 3.0)
+    ffi (1.9.3)
+    formatador (0.2.5)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.3.1)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    i18n (0.6.11)
+    listen (2.7.9)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    minitest (4.7.5)
+    multi_json (1.10.1)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    redis (3.1.0)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.3)
+    slop (3.6.0)
+    sqlite3 (1.3.9)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    timers (1.1.0)
+    tzinfo (0.3.40)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 4.0.8)
+  appraisal
+  bundler (~> 1.6)
+  counter-cache!
+  fakeredis
+  guard
+  guard-rspec
+  rake
+  rspec (>= 3.0)
+  sqlite3

data/gemfiles/activerecord_4.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.1.4"
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.1.gemfile.lock

@@ -0,0 +1,97 @@
+PATH
+  remote: ../
+  specs:
+    counter-cache (0.0.2)
+      activerecord (>= 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.4)
+      activesupport (= 4.1.4)
+      builder (~> 3.1)
+    activerecord (4.1.4)
+      activemodel (= 4.1.4)
+      activesupport (= 4.1.4)
+      arel (~> 5.0.0)
+    activesupport (4.1.4)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    appraisal (1.0.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    arel (5.0.1.20140414130214)
+    builder (3.2.2)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    fakeredis (0.5.0)
+      redis (~> 3.0)
+    ffi (1.9.3)
+    formatador (0.2.5)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.3.1)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    i18n (0.6.11)
+    json (1.8.1)
+    listen (2.7.9)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    minitest (5.4.0)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    redis (3.1.0)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.3)
+    slop (3.6.0)
+    sqlite3 (1.3.9)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    timers (1.1.0)
+    tzinfo (1.2.1)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 4.1.4)
+  appraisal
+  bundler (~> 1.6)
+  counter-cache!
+  fakeredis
+  guard
+  guard-rspec
+  rake
+  rspec (>= 3.0)
+  sqlite3

data/lib/counter/cache/counters/buffer_counter/relation_finder.rb

@@ -20,7 +20,7 @@ module Counter
           end
 
           def reflection_type
-            source_object.reflections[options.relation.to_sym].class_name.to_s.camelize # let AR give us the correct class name :)
+            source_object.class.reflections[options.relation.to_sym].class_name.to_s.camelize # let AR give us the correct class name :)
           end
         end
       end

data/lib/counter/cache/version.rb

@@ -1,5 +1,5 @@
 module Counter
   module Cache
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/spec/features/counter_spec.rb

@@ -6,7 +6,7 @@ require 'fakeredis'
 RSpec.describe "Counting" do
 
   before do
-    ActiveRecord::Base.silence { CreateModelsForTest.migrate(:up) }
+    CreateModelsForTest.migrate(:up)
     Counter::Cache.configure do |c|
       c.redis_pool = Redis.new
       c.default_worker_adapter = TestWorkerAdapter.new
@@ -14,7 +14,7 @@ RSpec.describe "Counting" do
   end
 
   after do
-    ActiveRecord::Base.silence { CreateModelsForTest.migrate(:down) }
+    CreateModelsForTest.migrate(:down)
   end
 
   let(:user) { User.create }

data/spec/lib/counter/cache/buffer_counter/relation_finder_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Counter::Cache::Counters::BufferCounter::RelationFinder do
       before do
         reflection = double
         expect(reflection).to receive_message_chain("class_name.to_s.camelize") { "Boo" }
-        expect(source_object).to receive(:reflections).and_return({:boo => reflection})
+        expect(source_object.class).to receive(:reflections).and_return({:boo => reflection})
       end
 
       it 'asks active record for the class name' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: counter-cache
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Paul Henry & Matt Camuto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -132,12 +146,20 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- Appraisals
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - counter-cache.gemspec
+- doc/counter-cache-flow.png
+- gemfiles/activerecord_3.gemfile
+- gemfiles/activerecord_3.gemfile.lock
+- gemfiles/activerecord_4.0.gemfile
+- gemfiles/activerecord_4.0.gemfile.lock
+- gemfiles/activerecord_4.1.gemfile
+- gemfiles/activerecord_4.1.gemfile.lock
 - lib/counter/cache.rb
 - lib/counter/cache/active_record_updater.rb
 - lib/counter/cache/config.rb
@@ -185,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Counting is hard.