double_write_cache_stores 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f2e06c115f9f6f2c93e70bd217a9f0d2277e4b8
-  data.tar.gz: 026266132650bcfe4a9b11f8a7ea78cbaeaaceeb
+  metadata.gz: 13d2f0ce282efcf499bf8fb33bbfead44f82d2d3
+  data.tar.gz: e5b840f484ca4cabb14ce53c952132f57b42709f
 SHA512:
-  metadata.gz: 7abdfd76502de8e42de745dbdd1ab4c729a126e3154e0572383720c70a27d06cd6e0e5e072963c57aaa8e1ca9833c81a4686278a489535e0b28d12e93735d2d7
-  data.tar.gz: 4ffd5deef56bd569014e711abf799c39217f2ae484c0ebc612d8868626a9f2152be6ac62c12f6a62f32c948c133ed24f7ac23788a681d8f47d6507efae24868b
+  metadata.gz: 5838cbbac0c8a973188aa26a85dea08895a2479049d9003b5c940220a05884b5f08c07dfab26c7caa4aa9b676f7239c3e4a015385d8dda3d10434f463a05349d
+  data.tar.gz: 9a1acfaf37c69dccd577ca88c2f58ff230cdf4e6d5d5c3391a599b240ae7cd1445cf7a9a3b4428556771e362a63e6071159814dc39f44e3c4cdbfcbff91218f5

data/.rubocop.yml

@@ -0,0 +1,60 @@
+AllCops:
+  Exclude:
+    - "vendor/**/*"
+  DisplayCopNames: true
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ExtraSpacing:
+  Enabled: false
+
+Style/GuardClause:
+  MinBodyLength: 5
+
+Style/MethodDefParentheses:
+  EnforcedStyle: require_parentheses
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/IndentationConsistency:
+  EnforcedStyle: rails
+
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+Style/HashSyntax:
+  EnforcedStyle: ruby19_no_mixed_keys
+  Exclude:
+    - "**/*.rake"
+    - "Rakefile"
+
+Metrics/LineLength:
+  Max: 160
+  Exclude:
+    - "db/migrate/*.rb"
+
+NumericLiterals:
+  MinDigits: 7
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Lint/BlockAlignment:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 12

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/.travis.yml

@@ -1,3 +1,21 @@
 language: ruby
+install: bundle install --jobs=3 --retry=3
+cache:
+  directories:
+  - vendor/bundle
 rvm:
-  - 2.1.0
+  - 2.2.3
+  - 2.1.7
+  - 2.0.0-p647
+
+gemfile:
+  - Gemfile
+  - activesupport.gemfile
+
+addons:
+  apt:
+    packages:
+    - memcached
+
+script:
+  - bundle exec rake spec

data/Gemfile

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

data/README.md

@@ -1,17 +1,14 @@
 # DoubleWriteCacheStores
 
-pre-warning(double write to cach store and other cache store) cache store wrapper. will switch cache store.
+[![Build Status](https://travis-ci.org/hirocaster/double_write_cache_stores.svg?branch=master)](https://travis-ci.org/hirocaster/double_write_cache_stores)
 
-## Convertible interface, get/set by cache store
-
-- Padrino::Cache(moneta)
-- ActiveSupport::Cache::DalliStore(Dalli)
-- Padrino::Cache::Store::Memcache
+pre-warming(double write to cach store and other cache store) cache store wrapper. will switch cache store.
 
 ## Support backend cache store
 
-- ActiveSupport::Cache::DalliStore(Dalli)
-- Padrino::Cache::Store::Memcache
+- ActiveSupport::Cache::MemCacheStore
+- ActiveSupport::Cache::DalliStore in Dalli
+- Dalli::Client
 
 ## Installation
 
@@ -32,6 +29,7 @@ Or install it yourself as:
 ### Padrino
 
 `config/apps.rb`
+
 ````
 read_and_write_cache_store = ActiveSupport::Cache.lookup_store :dalli_store, 'localhost:11211'
 write_only_cache_store = ActiveSupport::Cache.lookup_store :dalli_store, 'localhost:21211'
@@ -44,10 +42,14 @@ set :cache, DoubleWriteCacheStores::Client.new(read_and_write_cache_store, write
 `config/application.rb`
 
 ```ruby
-read_and_write_cache_store = ActiveSupport::Cache.lookup_store :mem_cache_store, 'localhost:11211'
-write_only_cache_store = ActiveSupport::Cache.lookup_store :mem_cache_store, 'localhost:21211'
+options = { expires_in: 1.week, compress: true }
+
+read_and_write_cache_store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost:11211", options
+config.middleware.insert_before "Rack::Runtime", read_and_write_cache_store.middleware
+
+write_only_cache_store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost:21211", options
 
-config.cache_store = DoubleWriteCacheStores::Client.new(read_and_write_cache_store, write_only_cache_store)
+config.cache_store = DoubleWriteCacheStores::Client.new read_and_write_cache_store, write_only_cache_store
 ```
 
 #### in application

data/activesupport.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem "rack"
+gem "activesupport"
+
+# Specify your gem's dependencies in active_record_sharding.gemspec
+gemspec

data/activesupport.gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    double_write_cache_stores (0.3.0)
+      dalli (~> 2.7.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    coderay (1.1.0)
+    dalli (2.7.4)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    method_source (0.8.2)
+    minitest (5.8.2)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.6.4)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    slop (3.6.0)
+    thread_safe (0.3.5)
+    tilt (1.3.7)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler (~> 1.5)
+  double_write_cache_stores!
+  pry
+  rack
+  rake
+  rspec
+  tilt (= 1.3.7)
+
+BUNDLED WITH
+   1.10.6

data/double_write_cache_stores.gemspec

@@ -1,29 +1,28 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'double_write_cache_stores/version'
+require "double_write_cache_stores/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "double_write_cache_stores"
   spec.version       = DoubleWriteCacheStores::VERSION
   spec.authors       = ["hirocaster"]
   spec.email         = ["hohtsuka@gmail.com"]
-  spec.summary       = %q{ Double write cache stores wrapper. }
-  spec.description   = %q{ pre-warning(double write to cach store and other cache store) cache store wrapper. will switch cache store. }
+  spec.summary       = "Double write cache stores wrapper."
+  spec.description   = "pre-warming(double write to cach store and other cache store) cache store wrapper. will switch cache store."
   spec.homepage      = ""
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   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_runtime_dependency "dalli", "~> 2.7.4"
+
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "activesupport", "= 3.2.15"
-  spec.add_development_dependency "dalli", "= 2.7.0"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "padrino", "0.10.7"
   spec.add_development_dependency "tilt", "1.3.7"
 end

data/lib/dalli_store_patch.rb

@@ -1,11 +1,15 @@
 # monky patch
 # support cas interface for ActiveSupport::Cache::DalliStore
 module DalliStorePatch
-  def read_cas(name, options=nil)
-    options ||= {}
+  def touch(key, ttl = nil)
+    ttl ||= options[:expires_in].to_i
+    @data.touch key, ttl
+  end
+
+  def read_cas(name, options = {})
     name = namespaced_key(name, options)
 
-    instrument(:get_cas, name) do |payload|
+    instrument(:get_cas, name) do |_payload|
       with { |c| c.get_cas(name) }
     end
   rescue Dalli::DalliError => e
@@ -14,12 +18,11 @@ module DalliStorePatch
     false
   end
 
-  def write_cas(name, value, options=nil)
-    options ||= {}
+  def write_cas(name, value, options = {})
     name = namespaced_key(name, options)
     expires_in = options[:expires_in]
 
-    instrument(:set_cas, name, value) do |payload|
+    instrument(:set_cas, name, value) do |_payload|
       cas = options.delete(:cas) || 0
       expires_in = options.delete(:expires_in)
       with { |c| c.set_cas(name, value, cas, expires_in, options) }
@@ -31,11 +34,9 @@ module DalliStorePatch
   end
 end
 
-
 begin
-  require "active_support"
   require "active_support/cache/dalli_store"
 
   ActiveSupport::Cache::DalliStore.send(:include, DalliStorePatch)
-rescue => exception
+rescue LoadError # rubocop:disable Lint/HandleExceptions
 end

data/lib/double_write_cache_stores.rb

@@ -1,6 +1,26 @@
+module DoubleWriteCacheStores
+  loaded_active_support = false
+
+  begin
+    require "active_support"
+    loaded_active_support = true
+  rescue LoadError # rubocop:disable Lint/HandleExceptions
+  end
+
+  loaded_active_support.freeze
+
+  LOADED_ACTIVE_SUPPORT = loaded_active_support
+
+  def self.loaded_active_support?
+    LOADED_ACTIVE_SUPPORT
+  end
+end
+
 require "double_write_cache_stores/version"
 require "double_write_cache_stores/client"
 require "double_write_cache_stores/base_exception"
+
+require "dalli"
 require "dalli_store_patch"
-module DoubleWriteCacheStores
-end
+
+require "mem_cache_store_patch" if DoubleWriteCacheStores.loaded_active_support?

data/lib/double_write_cache_stores/client.rb

@@ -1,217 +1,193 @@
-class DoubleWriteCacheStores::Client
-  def initialize(read_and_write_store_servers, write_only_store_servers = nil)
-    @read_and_write_store = read_and_write_store_servers
-    if write_only_store_servers
-      if read_and_write_store_servers.class != write_only_store_servers.class
-        fail "different cache store instance. #{read_and_write_store_servers.class} != #{write_only_store_servers.class}"
+module DoubleWriteCacheStores
+  class Client # rubocop:disable Metrics/ClassLength
+    attr_accessor :read_and_write_store, :write_only_store
+
+    def initialize(read_and_write_store_servers, write_only_store_servers = nil)
+      @read_and_write_store = read_and_write_store_servers
+      if write_only_store_servers
+        if read_and_write_store_servers.class != write_only_store_servers.class
+          raise "different cache store instance. #{read_and_write_store_servers.class} != #{write_only_store_servers.class}"
+        end
+        @write_only_store = write_only_store_servers
       end
-      @write_only_store = write_only_store_servers
     end
-  end
-
-  def [](key)
-    get key
-  end
-
-  def get(key)
-    get_or_read_method_call key
-  end
-
-  def get_multi(*keys)
-    get_multi_or_read_multi_method_call *keys
-  end
 
-  def get_cas(key)
-    if @read_and_write_store.respond_to? :get_cas
-      @read_and_write_store.get_cas key
-    elsif @read_and_write_store.respond_to? :read_cas
-      @read_and_write_store.read_cas key
+    def [](key)
+      get key
     end
-  end
 
-  def set_cas(key, value, cas=0, options=nil)
-    cas_unique = if @read_and_write_store.respond_to? :set_cas
-                   @read_and_write_store.set_cas key, value, cas, options
-                 elsif @read_and_write_store.respond_to? :read_cas
-                   options ||= {}
-                   options[:cas] = cas
-                   @read_and_write_store.write_cas key, value, options
-                 end
-
-    if @write_only_store && cas_unique
-      set_or_write_method_call @write_only_store, key, value, options
+    def get_cas(key)
+      if @read_and_write_store.respond_to? :get_cas
+        @read_and_write_store.get_cas key
+      elsif @read_and_write_store.respond_to? :read_cas
+        @read_and_write_store.read_cas key
+      end
     end
 
-    cas_unique
-  end
-
-  def read(key)
-    get_or_read_method_call key
-  end
-
-  def read_multi(*keys)
-    get_multi_or_read_multi_method_call *keys
-  end
-
-  def delete(key)
-    @read_and_write_store.delete key
-    @write_only_store.delete key if @write_only_store
-  end
-
-  def []=(key, value)
-    set key, value
-  end
+    def set_cas(key, value, cas = 0, options = nil)
+      cas_unique = if @read_and_write_store.respond_to? :set_cas
+                     @read_and_write_store.set_cas key, value, cas, options
+                   elsif @read_and_write_store.respond_to? :read_cas
+                     options ||= {}
+                     options[:cas] = cas
+                     @read_and_write_store.write_cas key, value, options
+                   end
+
+      if @write_only_store && cas_unique
+        set_or_write_method_call @write_only_store, key, value, options
+      end
 
-  def set(key, value, options = nil)
-    write_cache_store key, value, options
-  end
+      cas_unique
+    end
 
-  def write(key, value, options = nil)
-    write_cache_store key, value, options
-  end
+    def delete(key)
+      result = @read_and_write_store.delete key
+      @write_only_store.delete key if @write_only_store
+      result
+    end
 
-  def touch(key, ttl=nil)
-    result = false
-    if defined?(Dalli) && @read_and_write_store.is_a?(Dalli::Client)
-      result = @read_and_write_store.touch key, ttl
-    else
-      read_and_write_backend = @read_and_write_store.instance_variable_get('@backend') || @read_and_write_store.instance_variable_get('@data')
-      if read_and_write_backend && read_and_write_backend.respond_to?(:touch)
-        result = read_and_write_backend.touch key, ttl
-        write_only_store_touch key, ttl
-      end
+    def []=(key, value)
+      set key, value
     end
-    result
-  end
 
-  def flush
-    if flush_cache_store || flush_cache_store(:clear)
-      true
-    else
-      false
+    def touch(key, ttl = nil)
+      result = @read_and_write_store.touch key, ttl
+      @write_only_store.touch key, ttl if @write_only_store
+      result
     end
-  end
 
-  def fetch(name, options = nil)
-    if @read_and_write_store.respond_to?(:fetch) ||
-        (@write_only_store && @write_only_store.respond_to?(:fetch))
-      if block_given?
-        result = @read_and_write_store.fetch(name, options = nil) { yield }
-        @write_only_store.fetch(name, options = nil) { yield } if @write_only_store
-        result
+    def flush
+      if flush_cache_store || flush_cache_store(:clear)
+        true
       else
-        result = @read_and_write_store.fetch(name, options = nil)
-        @write_only_store.fetch(name, options = nil) if @write_only_store
-        result
+        false
       end
-    else
-      raise UnSupportException.new "Unsupported #fetch from client object."
     end
-  end
 
-  def increment(key, amount = 1, options = {})
-    increment_cache_store key, amount, options
-  end
-  alias_method :incr, :increment
+    def fetch(name, options = {}, &_block)
+      raise UnSupportException "Unsupported #fetch from client object." unless @read_and_write_store.respond_to?(:fetch)
 
-  def decrement(key, amount = 1, options = {})
-    decrement_cache_store key, amount, options
-  end
-  alias_method :decr, :decrement
-  
-  private
-
-  def write_cache_store(key, value, options = nil)
-    set_or_write_method_call @read_and_write_store, key, value, options
-    set_or_write_method_call @write_only_store, key, value, options if @write_only_store
-  end
+      delete name if options[:force]
 
-  def set_or_write_method_call cache_store, key, value, options
-    if cache_store.respond_to? :set
-      if defined?(Dalli) && cache_store.is_a?(Dalli::Client)
-        ttl = options[:expires_in] if options
-        cache_store.set key, value, ttl, options
+      if options[:race_condition_ttl]
+        fetch_race_condition name, options { yield }
       else
-        cache_store.set key, value, options
+        unless value = get_or_read_method_call(name)
+          value = yield
+          write_cache_store name, value, options
+        end
+        value
       end
-    elsif cache_store.respond_to? :write
-      cache_store.write key, value, options
     end
-  end
 
-  def get_or_read_method_call key
-    if @read_and_write_store.respond_to? :get
-      @read_and_write_store.get key
-    elsif @read_and_write_store.respond_to? :read
-      @read_and_write_store.read key
+    def increment(key, amount = 1, options = {})
+      increment_cache_store key, amount, options
     end
-  end
+    alias_method :incr, :increment
 
-  def get_multi_or_read_multi_method_call(*keys)
-    if @read_and_write_store.respond_to? :get_multi
-      @read_and_write_store.get_multi *keys
-    elsif @read_and_write_store.respond_to? :read_multi
-      @read_and_write_store.read_multi *keys
-    else
-      raise UnSupportException.new "Unsupported multi keys get or read from client object."
+    def decrement(key, amount = 1, options = {})
+      decrement_cache_store key, amount, options
     end
-  end
+    alias_method :decr, :decrement
 
-  def increment_cache_store(key, amount, options)
-    rw_store_value = incr_or_increment_method_call @read_and_write_store, key, amount, options
-    return rw_store_value unless @write_only_store
-    incr_or_increment_method_call @write_only_store, key, amount, options
-  end
+    def write_cache_store(key, value, options = nil)
+      set_or_write_method_call @read_and_write_store, key, value, options
+      set_or_write_method_call @write_only_store, key, value, options if @write_only_store
+    end
+    alias_method :set, :write_cache_store
+    alias_method :write, :write_cache_store
+
+    def get_or_read_method_call(key)
+      if @read_and_write_store.respond_to? :get
+        @read_and_write_store.get key
+      elsif @read_and_write_store.respond_to? :read
+        @read_and_write_store.read key
+      end
+    end
+    alias_method :get, :get_or_read_method_call
+    alias_method :read, :get_or_read_method_call
+
+    def get_multi_or_read_multi_method_call(*keys)
+      if @read_and_write_store.respond_to? :get_multi
+        @read_and_write_store.get_multi(*keys)
+      elsif @read_and_write_store.respond_to? :read_multi
+        @read_and_write_store.read_multi(*keys)
+      else
+        raise UnSupportException "Unsupported multi keys get or read from client object."
+      end
+    end
+    alias_method :get_multi, :get_multi_or_read_multi_method_call
+    alias_method :read_multi, :get_multi_or_read_multi_method_call
 
-  def decrement_cache_store(key, amount, options)
-    rw_store_value = decr_or_decrement_method_call @read_and_write_store, key, amount, options
-    return rw_store_value unless @write_only_store
-    decr_or_decrement_method_call @write_only_store, key, amount, options
-  end
+    private
 
-  def incr_or_increment_method_call(cache_store, key, amount, options)
-    if defined?(Dalli) && cache_store.is_a?(Dalli::Client)
-      ttl = options[:expires_in] if options
-      default = options.has_key?(:initial) ? options[:initial] : amount
-      cache_store.incr key, amount, ttl, default
-    elsif cache_store.respond_to? :increment
-      options[:initial] = amount unless options.has_key?(:initial)
-      cache_store.increment key, amount, options
-    end
-  end
+      def fetch_race_condition(key, options, &_block)
+        result = fetch_to_cache_store(@read_and_write_store, key, options) { yield }
+        fetch_to_cache_store(@write_only_store, key, options) { result } if @write_only_store && @write_only_store.respond_to?(:fetch)
+        result
+      end
 
-  def decr_or_decrement_method_call(cache_store, key, amount, options)
-    if defined?(Dalli) && cache_store.is_a?(Dalli::Client)
-      ttl = options[:expires_in] if options
-      default = options.has_key?(:initial) ? options[:initial] : 0
-      cache_store.decr key, amount, ttl, default
-    elsif cache_store.respond_to? :decrement
-      options[:initial] = 0 unless options.has_key?(:initial)
-      cache_store.decrement key, amount, options
-    end
-  end
+      def fetch_to_cache_store(cache_store, key, options, &_block)
+        if cache_store.is_a? Dalli::Client
+          ttl = options[:expires_in]
+          cache_store.fetch key, ttl, options { yield }
+        else
+          cache_store.fetch key, options { yield }
+        end
+      end
 
-  def flush_cache_store(method = :flush)
-    if @read_and_write_store.respond_to? method
-      if @write_only_store && @write_only_store.respond_to?(method)
-        @write_only_store.send method
+      def set_or_write_method_call(cache_store, key, value, options)
+        if cache_store.respond_to? :set
+          ttl = options[:expires_in] if options
+          cache_store.set key, value, ttl, options
+        elsif cache_store.respond_to? :write
+          cache_store.write key, value, options
+        end
       end
-      @read_and_write_store.send method
-    else
-      false
-    end
-  end
 
-  def write_only_store_touch(key, ttl)
-    if @write_only_store
-      if defined?(Dalli) && @write_only_store.is_a?(Dalli::Client)
-        @write_only_store.touch key, ttl
-      else
-        write_only_backend = @write_only_store.instance_variable_get('@backend') || @write_only_store.instance_variable_get('@data')
-        if write_only_backend
-          write_only_backend.touch(key, ttl) if write_only_backend.respond_to?(:touch)
+      def increment_cache_store(key, amount, options)
+        rw_store_value = incr_or_increment_method_call @read_and_write_store, key, amount, options
+        return rw_store_value unless @write_only_store
+        incr_or_increment_method_call @write_only_store, key, amount, options
+      end
+
+      def decrement_cache_store(key, amount, options)
+        rw_store_value = decr_or_decrement_method_call @read_and_write_store, key, amount, options
+        return rw_store_value unless @write_only_store
+        decr_or_decrement_method_call @write_only_store, key, amount, options
+      end
+
+      def incr_or_increment_method_call(cache_store, key, amount, options)
+        ttl = options[:expires_in] if options
+        default = options.key?(:initial) ? options[:initial] : amount
+        if cache_store.is_a? Dalli::Client
+          cache_store.incr key, amount, ttl, default
+        elsif cache_store.respond_to? :increment
+          options[:initial] = amount unless options.key?(:initial)
+          cache_store.increment key, amount, options
+        end
+      end
+
+      def decr_or_decrement_method_call(cache_store, key, amount, options)
+        if cache_store.is_a?(Dalli::Client)
+          ttl = options[:expires_in] if options
+          default = options.key?(:initial) ? options[:initial] : 0
+          cache_store.decr key, amount, ttl, default
+        elsif cache_store.respond_to? :decrement
+          options[:initial] = 0 unless options.key?(:initial)
+          cache_store.decrement key, amount, options
+        end
+      end
+
+      def flush_cache_store(method = :flush)
+        if @read_and_write_store.respond_to? method
+          if @write_only_store && @write_only_store.respond_to?(method)
+            @write_only_store.send method
+          end
+          @read_and_write_store.send method
+        else
+          false
         end
       end
-    end
   end
 end