cached_counter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d8e2382b12fc86f19c6dd734dfa801ff77f1e84d
+  data.tar.gz: f961dfb495177005b7f59e88e446bcc84dcf1588
+SHA512:
+  metadata.gz: 86a9b2d91155c1b4fea65fee55d0e5815d9869081cb737b993235dd4193625356ddbe687f04a1f0574b547eaaa722a5c6da9de0ad1001832b744379e1a0dbe4d
+  data.tar.gz: 8fc6a71789bd035a13c6e632041ebbfceb6ec852826194c977f09f3bd351179f3c6f30087adfd49eaaeef6088cdfa3a7d7d3ba3236fe9ddedf64b858b6536556

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*~
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,22 @@
+bundler_args: "--without development"
+language: ruby
+rvm:
+- 2.1.2
+- 2.1.3
+- ruby-head
+gemfile:
+- Gemfile
+matrix:
+  allow_failures:
+  - rvm: ruby-head
+  fast_finish: true
+services: memcache
+before_install: gem install bundler
+before_script:
+- echo $PWD
+- memcached -p 11212 -d
+script:
+- bundle exec rspec
+notifications:
+  slack:
+    secure: aVCX6aZuIS4QWS2GPaAvMulnUm3L5IBtIQCRI+BMQSZcvKKwidKz/jjCaVUSK1kyjQRIBh61B/SykMTZKtxi7HV7CMklpCXJGZeJdwhDRK1ZnfjvkO0AayMYYJ0NwzHLvHaOGCxyZIvQqUT8S6HwUVpxg4wjjMzLefqCx2c/8Ek=

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elasticsearch-model-extensions.gemspec
+gemspec path: File.dirname(__FILE__)
+
+group :test do
+  gem 'rspec', '~> 3.1.0'
+  gem 'database_cleaner'
+  gem 'coveralls', require: false
+end
+
+group :test, :development do
+  gem 'activerecord', '~> 3.2'
+  gem 'sqlite3'
+  gem 'delayed_job_active_record', '~> 4.0.1'
+  gem 'dalli', '~> 2.7.2'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Yusuke KUOKA
+
+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,77 @@
+# CachedCounter
+
+[![Build Status](https://travis-ci.org/crowdworks/cached_counter.svg?branch=master)](https://travis-ci.org/crowdworks/cached_counter)
+[![Coverage Status](https://coveralls.io/repos/crowdworks/cached_counter/badge.svg?branch=master)](https://coveralls.io/r/crowdworks/cached_counter?branch=master)
+[![Code Climate](https://codeclimate.com/github/crowdworks/cached_counter/badges/gpa.svg)](https://codeclimate.com/github/crowdworks/cached_counter)
+
+Cache Counter is an instantaneous but lock-friendly implementation of the counter.
+
+It allows to increment/decrement/get counts primarily saved in the database in a faster way.
+Utilizing the cache, it can be updated without big row-locks like the ActiveRecord's update_counters,
+with instantaneous and consistency unlike the updated_counters within delayed, background jobs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cached_counter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cached_counter
+
+## Usage
+
+```ruby
+# When you use the counter backed by Memcached via Dalli
+require 'dalli'
+require' cache_store'
+
+# Give the Cached Counter the name of the Cache Store and options you want to pass.
+# The built-in DalliCacheStore is named `:dalli` and accepts the `:hosts` option which is an array of Memcached hosts
+# you want Dalli connect to.
+CachedCounter.cache_store :dalli, hosts: %w| 127.0.0.1 |
+
+# We have an integer column named `num_read` in the `articles` table.
+article = Article.first
+
+# Give Cached Counter the record which has an attribute containing the initial value of the counter.
+cached_counter = CachedCounter.create(record: article, attribute: :num_read)
+
+article.num_read
+#=> 0
+cached_counter.value
+#=> 0
+
+# The value of the counter is updated immediately,
+# and a background job is scheduled to eventually update the value of the counter persisted in the database.
+cached_counter.increment
+
+# You can see the incremented value in the cache immediately
+cached_counter.value
+#=> 1
+
+# But not yet in the database
+article.reload.num_read
+#=> 0
+
+# When the scheduled background job is finished,
+# you can also see the incremented value in the database, too.
+article.reload.num_read
+#=> 1
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/crowdworks/cached_counter/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,2 @@
+require "bundler/gem_tasks"
+

data/cached_counter.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cached_counter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cached_counter"
+  spec.version       = CachedCounter::VERSION
+  spec.authors       = ["Yusuke KUOKA"]
+  spec.email         = ["ykuoka@gmail.com"]
+  spec.summary       = %q{An instantaneous but lock-friendly implementation of the counter}
+  spec.description   = %q{Cached Counter allows to increment/decrement/get counts primarily saved in the database in a faster way. Utilizing the cache, it can be updated without big row-locks like the ActiveRecord's update_counters, with instantaneous and consistency unlike the updated_counters within delayed, background jobs}
+  spec.homepage      = "https://github.com/crowdworks/cached_counter"
+  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_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/cached_counter.rb

@@ -0,0 +1,314 @@
+require "cached_counter/version"
+
+class CachedCounter
+  attr_reader :model_class, :attribute, :id
+
+  class ConcurrentCacheWriteError < StandardError; end
+
+  # @param [#call] cache_key The proc which takes the single argument of the class inheriting ActiveRecord::Base and returns a cache key
+  # @return [#call]
+  def self.cache_key(cache_key=nil)
+    if cache_key
+      @cache_key = cache_key
+    else
+      @cache_key ||= -> c { "#{c.model_class.model_name.cache_key}/#{c.attribute}/cached_counter/#{c.id}" }
+    end
+  end
+
+  # @param [#call] cache_store
+  # @return [CacheStore::Base]
+  def self.cache_store(cache_store=nil, *args, **options)
+    if cache_store
+      @cache_store = builder_for_cache_store(cache_store, *args, **options)
+    else
+      @cache_store
+    end
+  end
+
+  # @param [Proc]
+  def self.builder_for_cache_store(cache_store, *args, **options)
+    case cache_store
+    when Symbol
+      klass = cache_store_class_for_symbol(cache_store)
+      -> { klass.create(*args, **options) }
+    when Class
+      -> { cache_store.create(*args, **options)}
+    when Proc
+      cache_store
+    else
+      -> { cache_store }
+    end
+  end
+
+  # @param [Symbol] symbol
+  def self.cache_store_class_for_symbol(symbol)
+    const_get CacheStore.name + '::' + symbol.to_s.split('_').map(&:capitalize).join + 'CacheStore'
+  end
+
+  # @param [ActiveRecord::Base] record
+  # @param [Symbol] attribute
+  def self.create(record:, attribute:, cache_store: nil)
+    new(model_class: record.class, id: record.id, attribute: attribute, cache_store: cache_store)
+  end
+
+  def initialize(model_class:, id:, attribute:, cache_store: nil)
+    @model_class = model_class
+    @attribute = attribute
+    @id = id
+    @cache_store = cache_store
+  end
+
+  # Increment the specified attribute of the record utilizing the cache not to lock the table row as long as possible
+  def increment
+    cache_updated_successfully =
+      with_cache_store do |store|
+        begin
+          store.incr(cache_key) ||
+            # When the key doesn't exit in the cache because of cache expirations/clean-ups/restarts
+            store.add(cache_key, value_in_db + 1) ||
+            # In rare cases, the value for the key is updated by other client and we have to fail immediately, not to
+            # run into race-conditions.
+            raise(ConcurrentCacheWriteError, "Failing not to enter a race condition while writing a value for the key #{cache_key}")
+        rescue store.error_class => e
+          false
+        end
+      end
+
+    begin
+      if cache_updated_successfully
+        # When this database transaction failed afterward, we have to rollback the incrementation by decrementing
+        # the value in the cached.
+        # Without the rollback, we'll fall into an inconsistent state between the database and the cache.
+        on_error_rollback_by(:decrement_in_cache)
+
+        # As we have successfully incremented the value in the cache, we can rely on the cache in order to
+        # get/show the latest value.
+        # Therefore, we have no need to update the database record in realtime and we can achieve
+        # incrementing the counter with a little row-lock.
+        increment_in_db_later
+      else
+        # The cache service seems to be down, but we don't want to stop the application service.
+        # That's why we fall back to increment the value in the database which requires a bigger row-lock.
+        increment_in_db
+      end
+    rescue => e
+      raise e
+    end
+  end
+
+  def value
+    begin
+      cache_store.get(cache_key).try(&:to_i)
+    rescue cache_store.error_class => e
+      nil
+    end || value_in_db
+  end
+
+  # Decrement the specified attribute of the record utilizing the cache not to lock the table row as long as possible
+  def decrement
+    cache_updated_successfully =
+      with_cache_store do |store|
+        begin
+          store.decr(cache_key) ||
+            store.add(cache_key, value_in_db - 1) ||
+            raise(ConcurrentCacheWriteError, "Failing not to enter a race condition while writing a value for the key #{cache_key}")
+        rescue store.error_class => e
+          false
+        end
+      end
+
+    begin
+      if cache_updated_successfully
+        on_error_rollback_by(:increment_in_cache)
+
+        decrement_in_db_later
+      else
+        decrement_in_db
+      end
+    rescue => e
+      raise e
+    end
+  end
+
+  def value_in_db
+    @model_class.find(@id).send(@attribute)
+  end
+
+  def invalidate_cache
+    cache_store.delete(cache_key)
+  end
+
+  def increment_in_cache
+    with_cache_store do |d|
+      d.incr(cache_key)
+    end
+  end
+
+  def increment_in_db
+    @model_class.increment_counter(@attribute, @id)
+  end
+
+  def increment_in_db_later
+    call_method_later(:increment_in_db)
+  end
+
+  def decrement_in_cache
+    with_cache_store do |d|
+      d.decr(cache_key)
+    end
+  end
+
+  def decrement_in_db
+    @model_class.decrement_counter(@attribute, @id)
+  end
+
+  def decrement_in_db_later
+    call_method_later(:decrement_in_db)
+  end
+
+  # @return [String]
+  def cache_key
+    self.class.cache_key.call(self)
+  end
+
+  private
+
+  # @return [CacheStore::Base]
+  def cache_store
+    @cache_store ||= self.class.cache_store.call
+  end
+
+  def with_cache_store
+    yield cache_store
+  end
+
+  # @param [Symbol] method
+  def call_method_later(method)
+    CachedCounter::RetriedJob.new(
+      model_class: @model_class,
+      id: @id,
+      attribute: @attribute,
+      method: method
+    ).enqueue!
+  end
+
+  # @param [Symbol] method
+  def on_error_rollback_by(method)
+    listener = CachedCounter::RollbackByMethodCallListener.new(
+      model_class: @model_class,
+      id: @id,
+      attribute: @attribute,
+      method: method
+    )
+
+    # @see https://github.com/rails/rails/blob/v3.2.18/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb#L242
+    # @see https://github.com/rails/rails/blob/v4.1.4/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb#L248
+    @model_class.connection.add_transaction_record(listener)
+  end
+
+  class RetriedJob
+    def initialize(model_class:, id:, attribute:, method:)
+      @model_class = model_class
+      @id = id
+      @attribute = attribute
+      @method = method
+    end
+
+    def perform
+      CachedCounter.new(model_class: @model_class, id: @id, attribute: @attribute).send(@method)
+    end
+
+    def max_attempts
+      10
+    end
+
+    def enqueue!
+      Delayed::Job.enqueue self
+    end
+  end
+
+  class RollbackByMethodCallListener
+    def initialize(model_class:, id:, attribute:, method:)
+      @model_class = model_class
+      @id = id
+      @attribute = attribute
+      @method = method
+    end
+
+    # called only when Rails is 4+
+    # Without this method implemented, you will see `undefined method `has_transactional_callbacks?' for #<CachedCounter::RollbackByMethodCallListener:0x007f5af749cd80>`
+    # when the listener is passed to `#add_transaction_record`
+    # @see Rails 4: https://github.com/rails/rails/blob/v4.1.4/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb#L125
+    def has_transactional_callbacks?
+      true
+    end
+
+    # @see Rails 3: https://github.com/rails/rails/blob/v3.2.18/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb#L372
+    # @see Rails 4: https://github.com/rails/rails/blob/v4.1.4/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb#L147
+    def committed!
+      nil
+    end
+
+    # @see ActiveRecord::Transactions::rolledback!
+    # @see Rails 3: https://github.com/rails/rails/blob/v3.2.18/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb#L357
+    # @see Rails 4: https://github.com/rails/rails/blob/v4.1.4/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb#L136
+    def rolledback!(force_restore_state = false)
+      CachedCounter.new(model_class: @model_class, id: @id, attribute: @attribute).send(@method)
+    end
+  end
+
+  module CacheStore
+    class Base
+      def incr(key); fail_with_not_implemented_error 'incr' end
+      def decr(key); fail_with_not_implemented_error 'decr' end
+      def add(key, value); fail_with_not_implemented_error 'add' end
+      def delete(key); fail_with_not_implemented_error 'delete' end
+      def error_class; fail_with_not_implemented_error 'incr' end
+
+      private
+
+      def fail_with_not_implemented_error(method_name)
+        fail ::CacheStore::Base::NotImplementedError, "#{self.class.name}##{method_name} must be implemented."
+      end
+
+      class NotImplementedError < StandardError; end
+    end
+
+    class DalliCacheStore < Base
+      # @param [Dalli::Client] dalli_client
+      def initialize(dalli_client)
+        @dalli_client = dalli_client
+      end
+
+      def self.create(options={})
+        opts = options.dup
+        hosts = opts.delete(:hosts)
+        new(Dalli::Client.new(hosts, opts))
+      end
+
+      def incr(key)
+        @dalli_client.incr(key)
+      end
+
+      def decr(key)
+        @dalli_client.decr(key)
+      end
+
+      def add(key, value)
+        @dalli_client.add(key, value, 0, raw: true)
+      end
+
+      def get(key)
+        @dalli_client.get(key)
+      end
+
+      def delete(key)
+        @dalli_client.delete(key)
+      end
+
+      def error_class
+        Dalli::RingError
+      end
+    end
+  end
+end

data/lib/cached_counter/version.rb

@@ -0,0 +1,3 @@
+class CachedCounter
+  VERSION = "0.0.1"
+end

data/spec/cached_counter_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+require 'dalli'
+
+require 'cached_counter'
+
+RSpec.describe CachedCounter do
+  before(:each) do
+    load 'setup/articles_with_delayed_jobs.rb'
+
+    CachedCounter.cache_store :dalli, hosts: %w| 127.0.0.1 |
+  end
+
+  after :each do
+    ActiveRecord::Schema.define(:version => 2) do
+      drop_table :delayed_jobs
+      drop_table :articles
+    end
+  end
+
+  let(:cache_store) { CachedCounter.cache_store.call }
+  let(:cached_counter) { CachedCounter.create(record: record, attribute: :num_read, cache_store: cache_store) }
+  let(:record) { Article.first }
+
+  subject { cached_counter }
+
+  before do
+    cached_counter.invalidate_cache
+  end
+
+  describe '#increment' do
+    subject { -> { cached_counter.increment } }
+
+    it { is_expected.to change { cached_counter.value }.by(1) }
+    it { is_expected.not_to change { record.num_read} }
+    it { is_expected.to change { record.reload.num_read }.by(1) }
+
+    context 'when the surrounding transaction rolled-back' do
+      subject { -> { transaction }}
+
+      let(:transaction) {
+        begin
+          Article.transaction do
+            cached_counter.increment
+
+            fail 'simulated error'
+          end
+        rescue
+          ;
+        end
+      }
+
+      it { is_expected.not_to change { cached_counter.value } }
+      it { is_expected.not_to change { record.num_read } }
+      it { is_expected.not_to change { record.reload.num_read } }
+    end
+
+    context 'when the cache is updated concurrently' do
+      before do
+        expect(cache_store).to receive(:incr).and_return(false)
+        expect(cache_store).to receive(:add).and_return(false)
+      end
+
+      subject { -> { cached_counter.increment } }
+
+      it { is_expected.to raise_error(CachedCounter::ConcurrentCacheWriteError)}
+    end
+  end
+
+  describe '#decrement' do
+    subject { -> { cached_counter.decrement } }
+
+    it { is_expected.to change { cached_counter.value }.by(-1) }
+    it { is_expected.not_to change { record.num_read} }
+    it { is_expected.to change { record.reload.num_read }.by(-1) }
+
+    context 'when the surrounding transaction rolled-back' do
+      subject { -> { transaction }}
+
+      let(:transaction) {
+        begin
+          Article.transaction do
+            cached_counter.decrement
+
+            fail 'simulated error'
+          end
+        rescue
+          ;
+        end
+      }
+
+      it { is_expected.not_to change { cached_counter.value } }
+      it { is_expected.not_to change { record.num_read } }
+      it { is_expected.not_to change { record.reload.num_read } }
+    end
+
+    context 'when the cache is updated concurrently' do
+      before do
+        expect(cache_store).to receive(:decr).and_return(false)
+        expect(cache_store).to receive(:add).and_return(false)
+      end
+
+      subject { -> { cached_counter.decrement } }
+
+      it { is_expected.to raise_error(CachedCounter::ConcurrentCacheWriteError)}
+    end
+  end
+
+  context 'when the cache_store is not specified' do
+    let(:cache_store) { nil }
+
+    describe '#increment' do
+      subject { -> { cached_counter.increment } }
+
+      it { is_expected.to change { cached_counter.value }.by(1) }
+      it { is_expected.not_to change { record.num_read} }
+      it { is_expected.to change { record.reload.num_read }.by(1) }
+    end
+  end
+end

data/spec/setup/articles_with_delayed_jobs.rb

@@ -0,0 +1,35 @@
+load 'setup/undefine.rb'
+
+require 'delayed_job_active_record'
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :articles do |t|
+    t.string :title
+    t.integer :num_read, :default => 0
+    t.datetime :created_at, :default => 'NOW()'
+  end
+
+  create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0
+    table.integer  :attempts, :default => 0
+    table.text     :handler
+    table.text     :last_error
+    table.datetime :run_at
+    table.datetime :locked_at
+    table.datetime :failed_at
+    table.string   :locked_by
+    table.string   :queue
+    table.timestamps
+  end
+end
+
+Delayed::Worker.delay_jobs = false
+
+class ::Article < ActiveRecord::Base
+end
+
+Article.delete_all
+
+::Article.create! title: 'Test', num_read: 1
+::Article.create! title: 'Testing Coding'
+::Article.create! title: 'Coding'

data/spec/setup/sqlite.rb

@@ -0,0 +1,10 @@
+require 'active_record'
+require 'logger'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => "test.db")
+logger = ::Logger.new(STDERR)
+logger.formatter = lambda { |s, d, p, m| "\e[2;36m#{m}\e[0m\n" }
+ActiveRecord::Base.logger = logger unless ENV['QUIET']
+
+ActiveRecord::LogSubscriber.colorize_logging = false
+ActiveRecord::Migration.verbose = false

data/spec/setup/undefine.rb

@@ -0,0 +1,7 @@
+# Required to clear classes defined in `load 'setup/*.rb'` to make subsequent `load 'setup/*.rb'` to work correctly.
+%i| Article Comment AuthorProfile Author Tag Book |.each do |class_name|
+  if Object.const_defined?(class_name)
+    Object.send(:remove_const, class_name)
+    STDERR.puts "Undefined #{class_name}"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'coveralls'
+Coveralls.wear!
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.before :suite do
+    require 'setup/sqlite.rb'
+
+    require 'database_cleaner'
+
+    # https://github.com/DatabaseCleaner/database_cleaner#additional-activerecord-options-for-truncation
+    DatabaseCleaner.clean_with :deletion, cache_tables: false
+    DatabaseCleaner.strategy = :deletion
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+
+  config.before(:each) do |s|
+    md = s.metadata
+    x = md[:example_group]
+    STDERR.puts "==>>> #{x[:file_path]}:#{x[:line_number]} #{md[:description_args]}"
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: cached_counter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yusuke KUOKA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Cached Counter allows to increment/decrement/get counts primarily saved
+  in the database in a faster way. Utilizing the cache, it can be updated without
+  big row-locks like the ActiveRecord's update_counters, with instantaneous and consistency
+  unlike the updated_counters within delayed, background jobs
+email:
+- ykuoka@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cached_counter.gemspec
+- lib/cached_counter.rb
+- lib/cached_counter/version.rb
+- spec/cached_counter_spec.rb
+- spec/setup/articles_with_delayed_jobs.rb
+- spec/setup/sqlite.rb
+- spec/setup/undefine.rb
+- spec/spec_helper.rb
+homepage: https://github.com/crowdworks/cached_counter
+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.2.2
+signing_key: 
+specification_version: 4
+summary: An instantaneous but lock-friendly implementation of the counter
+test_files:
+- spec/cached_counter_spec.rb
+- spec/setup/articles_with_delayed_jobs.rb
+- spec/setup/sqlite.rb
+- spec/setup/undefine.rb
+- spec/spec_helper.rb