memcached_store 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a42e70078b5eda9cbbaf458f14785c0dacf41ebc
-  data.tar.gz: aae001ea0804778071cb51f155f85b625523ac02
+  metadata.gz: b05b5adfbadd1297a6914f2227a649e1bcd0d178
+  data.tar.gz: 9d8aa9dcf3f9435b00f5e5dd07697beda9930ab1
 SHA512:
-  metadata.gz: 77432128fdc4ea38984673d5551f13c2ff2abc886b96989dcd7f6db8a0de9d37d5e5648610feb055560ab5db56811fee02b307c9eea021ce2d0c00e371880819
-  data.tar.gz: fb8da4066ef04dcaea44d7fa746aa26a4b47d3c25e30971c2b8e52a59d693a0bf99e4285aae7c68ecbe42e6c136f4a5076d9e2d13afeabe3d835024dec3ec5fa
+  metadata.gz: 51829aa977156ed9c8c06bdab489b1f4febfc3c4aedd2d96555996b3a750bd0e64d7d2a708ebadbf51a9baf443f8e97c74622251eac7093dd9d0a9e85b64e5c9
+  data.tar.gz: c35fac05d247a305443a4732f2daf375f66066e3befc3266f5a6d78348ee20328f1cf2ce3cfb2a386c5d59de4e990633780aa5dcaa93055a71f37270f091a2ad

data/.gitignore

@@ -16,3 +16,5 @@ tmp
 .yardoc
 _yardoc
 doc/
+
+*.lock

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
+services: memcache
 rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
-services:
-  - memcache
+env:
+  - "AS_VERSION=3.2.16"
+  - "AS_VERSION=4.0.2"
+  - "AS_VERSION=4.1.0.beta1"

data/Gemfile

@@ -2,3 +2,14 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rails_cache_adapters.gemspec
 gemspec
+
+version = ENV["AS_VERSION"] || "3.2.16"
+as_version = case version
+when "master"
+  {:github => "rails/rails"}
+else
+  "~> #{version}"
+end
+
+gem 'minitest', '~> 4.0' if version == "3.2.16"
+gem "activesupport", as_version

data/README.md

@@ -6,7 +6,7 @@ ActiveSupport cache store that adds snappy compression at the cost of making the
 
 Add this line to your application's Gemfile:
 
-    gem 'memcached_snappy_store'
+    gem 'memcached_store'
 
 And then execute:
 
@@ -14,7 +14,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install memcached_snappy_store
+    $ gem install memcached_store
 
 ## Usage
 
@@ -29,7 +29,7 @@ In your environment file:
 
 ## Code status
 
-[![Build Status](https://travis-ci.org/Shopify/rails_cache_adapters.png)](https://travis-ci.org/Shopify/rails_cache_adapters)
+[![Build Status](https://travis-ci.org/Shopify/memcached_store.png?branch=accept-list-of-servers-in-options)](https://travis-ci.org/Shopify/memcached_store)
 
 ## Contributing
 

data/lib/active_support/cache/memcached_snappy_store.rb

@@ -1,6 +1,9 @@
+require 'active_support/cache/memcached_store'
+require 'snappy'
+
 module ActiveSupport
   module Cache
-    class MemcachedSnappyStore < Cache::MemCacheStore
+    class MemcachedSnappyStore < MemcachedStore
       class UnsupportedOperation < StandardError; end
 
       def increment(*args)
@@ -26,7 +29,7 @@ module ActiveSupport
 
         serialized_compressed_value = Snappy.deflate(serialized_value)
 
-        response = @data.set(escape_key(key), serialized_compressed_value, expires_in, true)
+        @data.set(escape_key(key), serialized_compressed_value, expires_in, true)
       end
 
       def deserialize_entry(compressed_value)

data/lib/active_support/cache/memcached_store.rb

@@ -0,0 +1,145 @@
+# file havily based out off https://github.com/rails/rails/blob/3-2-stable/activesupport/lib/active_support/cache/mem_cache_store.rb
+require 'digest/md5'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores data in Memcached:
+    # http://memcached.org/
+    #
+    # MemcachedStore uses memcached gem as backend to connect to Memcached server.
+    #
+    # MemcachedStore implements the Strategy::LocalCache strategy which implements
+    # an in-memory cache inside of a block.
+    class MemcachedStore < Store
+      FATAL_EXCEPTIONS = [ Memcached::ABadKeyWasProvidedOrCharactersOutOfRange,
+        Memcached::AKeyLengthOfZeroWasProvided,
+        Memcached::ConnectionBindFailure,
+        Memcached::ConnectionDataDoesNotExist,
+        Memcached::ConnectionFailure,
+        Memcached::ConnectionSocketCreateFailure,
+        Memcached::CouldNotOpenUnixSocket,
+        Memcached::NoServersDefined,
+        Memcached::TheHostTransportProtocolDoesNotMatchThatOfTheClient
+      ]
+
+      if defined?(::Rails) && ::Rails.env.test?
+        NONFATAL_EXCEPTIONS = []
+      else
+        NONFATAL_EXCEPTIONS = Memcached::EXCEPTIONS - FATAL_EXCEPTIONS
+      end
+
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
+
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        super(options)
+
+        if addresses.first.respond_to?(:get)
+          @data = addresses.first
+        else
+          mem_cache_options = options.dup
+          UNIVERSAL_OPTIONS.each{|name| mem_cache_options.delete(name)}
+          @data = Memcached::Rails.new(*(addresses + [mem_cache_options]))
+        end
+
+        extend Strategy::LocalCache
+      end
+
+      def read_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+        keys_to_names = Hash[names.map{|name| [escape_key(namespaced_key(name, options)), name]}]
+        raw_values = @data.get_multi(keys_to_names.keys, :raw => true)
+        values = {}
+        raw_values.each do |key, value|
+          entry = deserialize_entry(value)
+          values[keys_to_names[key]] = entry.value unless entry.expired?
+        end
+        values
+      end
+
+      def increment(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        instrument(:increment, name, :amount => amount) do
+          @data.incr(escape_key(namespaced_key(name, options)), amount)
+        end
+      rescue *NONFATAL_EXCEPTIONS => e
+        @data.log_exception(e)
+        nil
+      end
+
+      def decrement(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        instrument(:decrement, name, :amount => amount) do
+          @data.decr(escape_key(namespaced_key(name, options)), amount)
+        end
+      rescue *NONFATAL_EXCEPTIONS => e
+        @data.log_exception(e)
+        nil
+      end
+
+      def clear(options = nil)
+        @data.flush_all
+      end
+
+      def stats
+        @data.stats
+      end
+
+      def exist?(*args)
+        !!super
+      end
+
+      protected
+        def read_entry(key, options) # :nodoc:
+          deserialize_entry(@data.get(escape_key(key), true))
+        rescue *NONFATAL_EXCEPTIONS => e
+          @data.log_exception(e)
+          nil
+        end
+
+        def write_entry(key, entry, options) # :nodoc:
+          method = options && options[:unless_exist] ? :add : :set
+          value = options[:raw] ? entry.value.to_s : entry
+          expires_in = options[:expires_in].to_i
+          if expires_in > 0 && !options[:raw]
+            # Set the memcache expire a few minutes in the future to support race condition ttls on read
+            expires_in += 5.minutes
+          end
+          @data.send(method, escape_key(key), value, expires_in, options[:raw])
+        rescue *NONFATAL_EXCEPTIONS => e
+          @data.log_exception(e)
+          false
+        end
+
+        def delete_entry(key, options) # :nodoc:
+          @data.delete(escape_key(key))
+          true
+        rescue *NONFATAL_EXCEPTIONS => e
+          @data.log_exception(e)
+          false
+        end
+
+      private
+
+        def escape_key(key)
+          key = key.to_s.dup
+          key = key.force_encoding(Encoding::ASCII_8BIT)
+          key = key.gsub(ESCAPE_KEY_CHARS){ |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
+          key
+        end
+
+        def deserialize_entry(raw_value)
+          if raw_value
+            entry = Marshal.load(raw_value) rescue raw_value
+            entry.is_a?(Entry) ? entry : Entry.new(entry)
+          else
+            nil
+          end
+        end
+
+    end
+  end
+end

data/lib/memcached_store.rb

@@ -1,2 +1,3 @@
+require "memcached"
 require "active_support/cache"
 require "memcached_store/memcached_safety"

data/lib/memcached_store/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module MemcachedStore
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/memcached_store.gemspec

@@ -17,11 +17,10 @@ Gem::Specification.new do |gem|
   gem.version       = MemcachedStore::VERSION
   gem.add_runtime_dependency "activesupport", ">=  3.2"
   gem.add_runtime_dependency "snappy", "0.0.4"
-  gem.add_development_dependency "i18n"
+  gem.add_runtime_dependency "memcached", "~> 1.5.0"
+
   gem.add_development_dependency "rake"
   gem.add_development_dependency "minitest"
   gem.add_development_dependency "mocha"
   gem.add_development_dependency "timecop"
-  gem.add_development_dependency "memcached"
-  gem.add_development_dependency "memcache-client"
 end

data/test/test_helper.rb

@@ -1,8 +1,7 @@
-require 'snappy'
-require 'memcached'
 require 'minitest/autorun'
-require 'active_support/cache'
-require 'active_support'
 require 'mocha/setup'
 require 'timecop'
+
+require 'active_support/test_case'
+
 require 'memcached_store'

data/test/test_memcached_store.rb

@@ -0,0 +1,291 @@
+require 'test_helper'
+
+class TestMemcachedStore < ActiveSupport::TestCase
+  setup do
+    @cache = ActiveSupport::Cache.lookup_store(:memcached_store, expires_in: 60)
+    @cache.clear
+  end
+
+  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
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 10)
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    Time.stubs(:now).returns(time + 11)
+    assert_equal({"fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  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)
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+    assert_equal 'bar', @cache.read('foo')
+  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_equal true, @cache.exist?('foo')
+    assert_equal false, @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')
+
+    assert @cache.delete('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 + 91)
+    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
+
+  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
+    assert_nil @cache.increment('bar')
+  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
+    assert_nil @cache.decrement('bar')
+  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
+
+  def test_initialize_accepts_a_list_of_servers_in_options
+    options = {servers: ["localhost:21211"]}
+    cache = ActiveSupport::Cache.lookup_store(:memcached_store, options)
+    assert_equal 21211, cache.instance_variable_get(:@data).servers.first.port
+  end
+
+  def test_multiple_servers
+    options = {servers: ["localhost:21211", "localhost:11211"]}
+    cache = ActiveSupport::Cache.lookup_store(:memcached_store, options)
+    assert_equal [21211, 11211], cache.instance_variable_get(:@data).servers.map(&:port)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memcached_store
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Camilo Lopez
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-09 00:00:00.000000000 Z
+date: 2014-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -41,19 +41,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.0.4
 - !ruby/object:Gem::Dependency
-  name: i18n
+  name: memcached
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 1.5.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -110,34 +110,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: memcached
-  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: memcache-client
-  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: Plugin-able Memcached adapters to add features (compression, safety)
 email:
 - camilo@camilolopez.com
@@ -150,11 +122,11 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
 - lib/active_support/cache/memcached_snappy_store.rb
+- lib/active_support/cache/memcached_store.rb
 - lib/memcached_store.rb
 - lib/memcached_store/memcached_safety.rb
 - lib/memcached_store/version.rb
@@ -162,6 +134,7 @@ files:
 - test/test_helper.rb
 - test/test_memcached_safety.rb
 - test/test_memcached_snappy_store.rb
+- test/test_memcached_store.rb
 homepage: https://github.com/Shopify/memcached_store/
 licenses: []
 metadata: {}
@@ -189,3 +162,4 @@ test_files:
 - test/test_helper.rb
 - test/test_memcached_safety.rb
 - test/test_memcached_snappy_store.rb
+- test/test_memcached_store.rb

data/Gemfile.lock

@@ -1,37 +0,0 @@
-PATH
-  remote: .
-  specs:
-    memcached_store (0.10.0)
-      activesupport (>= 3.2)
-      snappy (= 0.0.4)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (3.2.13)
-      i18n (= 0.6.1)
-      multi_json (~> 1.0)
-    i18n (0.6.1)
-    memcache-client (1.8.5)
-    memcached (1.5.0)
-    metaclass (0.0.1)
-    minitest (4.7.1)
-    mocha (0.13.3)
-      metaclass (~> 0.0.1)
-    multi_json (1.8.3)
-    rake (10.0.4)
-    snappy (0.0.4)
-    timecop (0.6.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  i18n
-  memcache-client
-  memcached
-  memcached_store!
-  minitest
-  mocha
-  rake
-  timecop