activesupport-cascadestore 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in activesupport-cascadestore.gemspec
+gemspec

data/README.md

@@ -0,0 +1,45 @@
+# ActiveSupport::Cache::CascadeStore
+
+Hopefully this cache store is merged upstream into core
+with [this pull request](https://github.com/rails/rails/pull/5263).
+In the meantime, packaging this up as a gem for easy access.
+
+A thread-safe cache store implementation that cascades
+operations to a list of other cache stores. It is used to
+provide fallback cache stores when primary stores become
+unavailable, or to put lower latency stores in front of
+other cache stores.
+
+For example, to initialize a CascadeStore that
+cascades through MemCacheStore, MemoryStore, and FileStore:
+
+    ActiveSupport::Cache.lookup_store(:cascade_store,
+      :stores => [
+        :mem_cache_store,
+        :memory_store,
+        :file_store
+      ]
+    })
+
+Cache operation behavior:
+
+Read: returns first cache hit from :stores, nil if none found
+
+Write/Delete: write/delete through to each cache store in
+:stores
+
+Increment/Decrement: increment/decrement each store, returning
+the new number if any stores was successfully
+incremented/decremented, nil otherwise
+
+### Development
+
+To run tests
+
+```
+ruby -Itest test/caching_test.rb
+```
+
+### License
+
+Same license as [Rails](http://github.com/rails/rails)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activesupport-cascadestore.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "activesupport-cascadestore"
+  s.version     = "0.0.1"
+  s.authors     = ["Jerry Cheung"]
+  s.email       = ["jch@whatcodecraves.com"]
+  s.homepage    = "http://github.com/jch/activesupport-cascadestore"
+  s.summary     = %q{write-through cache store that allows you to chain multiple cache stores together}
+  s.description = %q{write-through cache store that allows you to chain multiple cache stores together}
+
+  s.rubyforge_project = "activesupport-cascadestore"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "activesupport"
+end

data/lib/active_support/cache/cascade_store.rb

@@ -0,0 +1,97 @@
+require 'monitor'
+
+module ActiveSupport
+  module Cache
+    # A thread-safe cache store implementation that cascades
+    # operations to a list of other cache stores. It is used to
+    # provide fallback cache stores when primary stores become
+    # unavailable. For example, to initialize a CascadeStore that
+    # cascades through MemCacheStore, MemoryStore, and FileStore:
+    #
+    #     ActiveSupport::Cache.lookup_store(:cascade_store,
+    #       :stores => [
+    #         :mem_cache_store,
+    #         :memory_store,
+    #         :file_store
+    #       ]
+    #     })
+    #
+    # Cache operation behavior:
+    #
+    # Read: returns first cache hit from :stores, nil if none found
+    #
+    # Write/Delete: write/delete through to each cache store in
+    # :stores
+    #
+    # Increment/Decrement: increment/decrement each store, returning
+    # the new number if any stores was successfully
+    # incremented/decremented, nil otherwise
+    class CascadeStore < Store
+      attr_reader :stores
+
+      # Initialize a CascadeStore with +options[:stores]+, an array of
+      # options to initialize other ActiveSupport::Cache::Store
+      # implementations.  If options is a symbol, top level
+      # CascadeStore options are used for cascaded stores. If options
+      # is an array, they are passed on unchanged.
+      def initialize(options = nil, &blk)
+        options ||= {}
+        super(options)
+        @monitor = Monitor.new
+        store_options = options.delete(:stores) || []
+        @stores = store_options.map do |o|
+          o = o.is_a?(Symbol) ? [o, options] : o
+          ActiveSupport::Cache.lookup_store(*o)
+        end
+      end
+
+      def increment(name, amount = 1, options = nil)
+        nums = cascade(:increment, name, amount, options)
+        nums.detect {|n| !n.nil?}
+      end
+
+      def decrement(name, amount = 1, options = nil)
+        nums = cascade(:decrement, name, amount, options)
+        nums.detect {|n| !n.nil?}
+      end
+
+      def delete_matched(matcher, options = nil)
+        cascade(:delete_matched, matcher, options)
+        nil
+      end
+
+      protected
+      def synchronize(&block) # :nodoc:
+        @monitor.synchronize(&block)
+      end
+
+      def cascade(method, *args) # :nodoc:
+        synchronize do
+          @stores.map do |store|
+            store.send(method, *args) rescue nil
+          end
+        end
+      end
+
+      def read_entry(key, options) # :nodoc:
+        entry = nil
+        synchronize do
+          @stores.detect do |store|
+            entry = store.send(:read_entry, key, options)
+          end
+        end
+        entry
+      end
+
+      def write_entry(key, entry, options) # :nodoc:
+        cascade(:write_entry, key, entry, options)
+        true
+      end
+
+      def delete_entry(key, options) # :nodoc:
+        cascade(:delete_entry, key, options)
+        true
+      end
+    end
+  end
+end

data/lib/activesupport-cascadestore.rb

@@ -0,0 +1 @@
+require "active_support/cache"

data/test/abstract_unit.rb

@@ -0,0 +1,40 @@
+ORIG_ARGV = ARGV.dup
+
+# begin
+#   old, $VERBOSE = $VERBOSE, nil
+#   require File.expand_path('../../../load_paths', __FILE__)
+# ensure
+#   $VERBOSE = old
+# end
+
+lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
+
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/string/encoding'
+
+silence_warnings do
+  Encoding.default_internal = "UTF-8"
+  Encoding.default_external = "UTF-8"
+end
+
+require 'minitest/autorun'
+# require 'empty_bool'
+
+silence_warnings { require 'mocha' }
+
+ENV['NO_RELOAD'] = '1'
+require 'active_support'
+
+def uses_memcached(test_name)
+  require 'memcache'
+  begin
+    MemCache.new('localhost:11211').stats
+    yield
+  rescue MemCache::MemCacheError
+    $stderr.puts "Skipping #{test_name} tests. Start memcached and try again."
+  end
+end
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true

data/test/caching_test.rb

@@ -0,0 +1,374 @@
+require 'logger'
+require 'abstract_unit'
+require 'active_support/cache'
+
+# Tests the base functionality that should be identical across all cache stores.
+module CacheStoreBehavior
+  def test_should_read_and_write_strings
+    assert @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_should_overwrite
+    @cache.write('foo', 'bar')
+    @cache.write('foo', 'baz')
+    assert_equal 'baz', @cache.read('foo')
+  end
+
+  def test_fetch_without_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:write).never
+    assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_cache_miss
+    @cache.expects(:write).with('foo', 'baz', @cache.options)
+    assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_forced_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:read).never
+    @cache.expects(:write).with('foo', 'bar', @cache.options.merge(:force => true))
+    @cache.fetch('foo', :force => true) { 'bar' }
+  end
+
+  def test_fetch_with_cached_nil
+    @cache.write('foo', nil)
+    @cache.expects(:write).never
+    assert_nil @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_should_read_and_write_hash
+    assert @cache.write('foo', {:a => "b"})
+    assert_equal({:a => "b"}, @cache.read('foo'))
+  end
+
+  def test_should_read_and_write_integer
+    assert @cache.write('foo', 1)
+    assert_equal 1, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_nil
+    assert @cache.write('foo', nil)
+    assert_equal nil, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_false
+    assert @cache.write('foo', false)
+    assert_equal false, @cache.read('foo')
+  end
+
+  def test_read_multi
+    @cache.write('foo', 'bar')
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_read_multi_with_expires
+    @cache.write('foo', 'bar', :expires_in => 0.001)
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    sleep(0.002)
+    assert_equal({"fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_read_and_write_compressed_small_data
+    @cache.write('foo', 'bar', :compress => true)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    assert_equal 'bar', Marshal.load(raw_value)
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    assert_equal 'bar', Marshal.load(Zlib::Inflate.inflate(raw_value))
+  end
+
+  def test_read_and_write_compressed_nil
+    @cache.write('foo', nil, :compress => true)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_cache_key
+    obj = Object.new
+    def obj.cache_key
+      :foo
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_param_as_cache_key
+    obj = Object.new
+    def obj.to_param
+      "foo"
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_array_as_cache_key
+    @cache.write([:fu, "foo"], "bar")
+    assert_equal "bar", @cache.read("fu/foo")
+  end
+
+  def test_hash_as_cache_key
+    @cache.write({:foo => 1, :fu => 2}, "bar")
+    assert_equal "bar", @cache.read("foo=1/fu=2")
+  end
+
+  def test_keys_are_case_sensitive
+    @cache.write("foo", "bar")
+    assert_nil @cache.read("FOO")
+  end
+
+  def test_exist
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    assert !@cache.exist?('bar')
+  end
+
+  def test_nil_exist
+    @cache.write('foo', nil)
+    assert @cache.exist?('foo')
+  end
+
+  def test_delete
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    assert @cache.delete('foo')
+    assert !@cache.exist?('foo')
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write('foo', 'bar')
+    assert_not_equal @cache.read('foo').object_id, @cache.read('foo').object_id
+    value = @cache.read('foo')
+    value << 'bingo'
+    assert_not_equal value, @cache.read('foo')
+  end
+
+  def test_original_store_objects_should_not_be_immutable
+    bar = 'bar'
+    @cache.write('foo', bar)
+    assert_nothing_raised { bar.gsub!(/.*/, 'baz') }
+  end
+
+  def test_expires_in
+    time = Time.local(2008, 4, 24)
+    Time.stubs(:now).returns(time)
+
+    @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+
+    Time.stubs(:now).returns(time + 30)
+    assert_equal 'bar', @cache.read('foo')
+
+    Time.stubs(:now).returns(time + 61)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_race_condition_protection
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 61)
+    result = @cache.fetch('foo', :race_condition_ttl => 10) do
+      assert_equal 'bar', @cache.read('foo')
+      "baz"
+    end
+    assert_equal "baz", result
+  end
+
+  def test_race_condition_protection_is_limited
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 71)
+    result = @cache.fetch('foo', :race_condition_ttl => 10) do
+      assert_equal nil, @cache.read('foo')
+      "baz"
+    end
+    assert_equal "baz", result
+  end
+
+  def test_race_condition_protection_is_safe
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 61)
+    begin
+      @cache.fetch('foo', :race_condition_ttl => 10) do
+        assert_equal 'bar', @cache.read('foo')
+        raise ArgumentError.new
+      end
+    rescue ArgumentError
+    end
+    assert_equal "bar", @cache.read('foo')
+    Time.stubs(:now).returns(time + 71)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_crazy_key_characters
+    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
+    assert @cache.write(crazy_key, "1", :raw => true)
+    assert_equal "1", @cache.read(crazy_key)
+    assert_equal "1", @cache.fetch(crazy_key)
+    assert @cache.delete(crazy_key)
+    assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
+    assert_equal 3, @cache.increment(crazy_key)
+    assert_equal 2, @cache.decrement(crazy_key)
+  end
+
+  def test_really_long_keys
+    key = ""
+    900.times{key << "x"}
+    assert @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+    assert_equal "bar", @cache.fetch(key)
+    assert_nil @cache.read("#{key}x")
+    assert_equal({key => "bar"}, @cache.read_multi(key))
+    assert @cache.delete(key)
+  end
+end
+
+# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
+# The error is caused by charcter encodings that can't be compared with ASCII-8BIT regular expressions and by special
+# characters like the umlaut in UTF-8.
+module EncodedKeyCacheBehavior
+  Encoding.list.each do |encoding|
+    define_method "test_#{encoding.name.underscore}_encoded_values" do
+      key = "foo".force_encoding(encoding)
+      assert @cache.write(key, "1", :raw => true)
+      assert_equal "1", @cache.read(key)
+      assert_equal "1", @cache.fetch(key)
+      assert @cache.delete(key)
+      assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
+      assert_equal 3, @cache.increment(key)
+      assert_equal 2, @cache.decrement(key)
+    end
+  end
+
+  def test_common_utf8_values
+    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", :raw => true)
+    assert_equal "1", @cache.read(key)
+    assert_equal "1", @cache.fetch(key)
+    assert @cache.delete(key)
+    assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
+    assert_equal 3, @cache.increment(key)
+    assert_equal 2, @cache.decrement(key)
+  end
+
+  def test_retains_encoding
+    key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
+    assert @cache.write(key, "1", :raw => true)
+    assert_equal Encoding::UTF_8, key.encoding
+  end
+end
+
+module CacheDeleteMatchedBehavior
+  def test_delete_matched
+    @cache.write("foo", "bar")
+    @cache.write("fu", "baz")
+    @cache.write("foo/bar", "baz")
+    @cache.write("fu/baz", "bar")
+    @cache.delete_matched(/oo/)
+    assert !@cache.exist?("foo")
+    assert @cache.exist?("fu")
+    assert !@cache.exist?("foo/bar")
+    assert @cache.exist?("fu/baz")
+  end
+end
+
+module CacheIncrementDecrementBehavior
+  def test_increment
+    @cache.write('foo', 1, :raw => true)
+    assert_equal 1, @cache.read('foo').to_i
+    assert_equal 2, @cache.increment('foo')
+    assert_equal 2, @cache.read('foo').to_i
+    assert_equal 3, @cache.increment('foo')
+    assert_equal 3, @cache.read('foo').to_i
+  end
+
+  def test_decrement
+    @cache.write('foo', 3, :raw => true)
+    assert_equal 3, @cache.read('foo').to_i
+    assert_equal 2, @cache.decrement('foo')
+    assert_equal 2, @cache.read('foo').to_i
+    assert_equal 1, @cache.decrement('foo')
+    assert_equal 1, @cache.read('foo').to_i
+  end
+end
+
+class CascadeStoreTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:cascade_store, {
+      :expires_in => 60,
+      :stores => [
+        :memory_store,
+        [:memory_store, :expires_in => 60]
+      ]
+    })
+    @store1 = @cache.stores[0]
+    @store2 = @cache.stores[1]
+  end
+
+  include CacheStoreBehavior
+  include CacheIncrementDecrementBehavior
+  include CacheDeleteMatchedBehavior
+  include EncodedKeyCacheBehavior
+
+  def test_default_child_store_options
+    assert_equal @store1.options[:expires_in], 60
+  end
+
+  def test_empty_store_cache_miss
+    cache = ActiveSupport::Cache.lookup_store(:cascade_store)
+    assert cache.write('foo', 'bar')
+    assert cache.fetch('foo').nil?
+  end
+
+  def test_cascade_write
+    @cache.write('foo', 'bar')
+    assert_equal @store1.read('foo'), 'bar'
+    assert_equal @store2.read('foo'), 'bar'
+  end
+
+  def test_cascade_read_returns_first_hit
+    @store1.write('foo', 'bar')
+    @store2.expects(:read_entry).never
+    assert_equal @cache.read('foo'), 'bar'
+  end
+
+  def test_cascade_read_fallback
+    @store1.delete('foo')
+    @store2.write('foo', 'bar')
+    assert_equal @cache.read('foo'), 'bar'
+  end
+
+  def test_cascade_read_not_found
+    assert_equal @cache.read('foo'), nil
+  end
+
+  def test_cascade_delete
+    @store1.write('foo', 'bar')
+    @store2.write('foo', 'bar')
+    @cache.delete('foo')
+    assert_equal @store1.read('foo'), nil
+    assert_equal @store2.read('foo'), nil
+  end
+
+  def test_cascade_increment_partial_returns_num
+    @store2.write('foo', 0)
+    assert_equal @cache.increment('foo', 1), 1
+    assert_equal @cache.read('foo'), 1
+  end
+
+  def test_cascade_decrement_partial_returns_num
+    @store2.write('foo', 1)
+    assert_equal @cache.decrement('foo', 1), 0
+    assert_equal @cache.read('foo'), 0
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: activesupport-cascadestore
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jerry Cheung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70233264692760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70233264692760
+description: write-through cache store that allows you to chain multiple cache stores
+  together
+email:
+- jch@whatcodecraves.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- activesupport-cascadestore.gemspec
+- lib/active_support/cache/cascade_store.rb
+- lib/activesupport-cascadestore.rb
+- test/abstract_unit.rb
+- test/caching_test.rb
+homepage: http://github.com/jch/activesupport-cascadestore
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: activesupport-cascadestore
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: write-through cache store that allows you to chain multiple cache stores
+  together
+test_files:
+- test/abstract_unit.rb
+- test/caching_test.rb
+has_rdoc: