memcached_store 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a42e70078b5eda9cbbaf458f14785c0dacf41ebc
+  data.tar.gz: aae001ea0804778071cb51f155f85b625523ac02
+SHA512:
+  metadata.gz: 77432128fdc4ea38984673d5551f13c2ff2abc886b96989dcd7f6db8a0de9d37d5e5648610feb055560ab5db56811fee02b307c9eea021ce2d0c00e371880819
+  data.tar.gz: fb8da4066ef04dcaea44d7fa746aa26a4b47d3c25e30971c2b8e52a59d693a0bf99e4285aae7c68ecbe42e6c136f4a5076d9e2d13afeabe3d835024dec3ec5fa

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+services:
+  - memcache

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,37 @@
+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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Camilo Lopez
+
+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,40 @@
+# MemcachedSnappyStore
+
+ActiveSupport cache store that adds snappy compression at the cost of making the ```incr, decr, add``` operations unavailable. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'memcached_snappy_store'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install memcached_snappy_store
+
+## Usage
+
+In your environment file:
+
+```ruby
+
+  config.cache_store = :memcached_snappy_store,  
+    Memcached::Rails.new(:servers => ['memcached1.foo.com', 'memcached2.foo.com']) 
+
+```
+
+## Code status
+
+[![Build Status](https://travis-ci.org/Shopify/rails_cache_adapters.png)](https://travis-ci.org/Shopify/rails_cache_adapters)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,32 @@
+#!/usr/bin/env rake
+require 'rake'
+require 'rake/testtask'
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "memcached_store/version"
+
+task :default => 'test'
+
+desc 'run test suite with default parser'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.libs << "lib/**/*"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+task :gem => :build
+task :build do
+  system "gem build memcached_store.gemspec"
+end
+
+task :install => :build do
+  system "gem install memcached_store-#{MemcachedStore::VERSION}.gem"
+end
+
+task :release => :build do
+  system "git commit -m'Released version #{MemcachedStore::VERSION}' --allow-empty"
+  system "git tag -a v#{MemcachedStore::VERSION} -m 'Tagging #{MemcachedStore::VERSION}'"
+  system "git push --tags"
+  system "gem push memcached_store-#{MemcachedStore::VERSION}.gem"
+  system "rm memcached_store-#{MemcachedStore::VERSION}.gem"
+end

data/lib/active_support/cache/memcached_snappy_store.rb

@@ -0,0 +1,38 @@
+module ActiveSupport
+  module Cache
+    class MemcachedSnappyStore < Cache::MemCacheStore
+      class UnsupportedOperation < StandardError; end
+
+      def increment(*args)
+        raise UnsupportedOperation.new("increment is not supported by: #{self.class.name}")
+      end
+
+      def decrement(*args)
+        raise UnsupportedOperation.new("decrement is not supported by: #{self.class.name}")
+      end
+
+      protected
+
+      def write_entry(key, entry, options)
+        # normally unless_exist would make this method use add,  add will not make sense on compressed entries
+        raise UnsupportedOperation.new("unless_exist would try to use the unsupported add method") if options && options[:unless_exist]
+
+        serialized_value = options[:raw] ? entry.value.to_s : Marshal.dump(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
+
+        serialized_compressed_value = Snappy.deflate(serialized_value)
+
+        response = @data.set(escape_key(key), serialized_compressed_value, expires_in, true)
+      end
+
+      def deserialize_entry(compressed_value)
+        decompressed_value = compressed_value.nil? ? compressed_value : Snappy.inflate(compressed_value)
+        super(decompressed_value)
+      end
+    end
+  end
+end

data/lib/memcached_store.rb

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

data/lib/memcached_store/memcached_safety.rb

@@ -0,0 +1,68 @@
+module MemcachedStore
+  class MemcachedSafety < Memcached::Rails
+
+    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
+
+    SIZE_LIMIT = 2 * 1024 * 1024
+
+    def exist_with_rescue?(*args)
+      exist_without_rescue?(*args)
+    rescue *NONFATAL_EXCEPTIONS
+    end
+    alias_method :exist_without_rescue?, :exist?
+    alias_method :exist?, :exist_with_rescue?
+
+    def cas_with_rescue(*args)
+      cas_without_rescue(*args)
+    rescue *NONFATAL_EXCEPTIONS
+      false
+    end
+    alias_method_chain :cas, :rescue
+
+    def get_multi_with_rescue(*args)
+      get_multi_without_rescue(*args)
+    rescue *NONFATAL_EXCEPTIONS
+      {}
+    end
+    alias_method_chain :get_multi, :rescue
+
+    def set_with_rescue(*args)
+      set_without_rescue(*args)
+    rescue *NONFATAL_EXCEPTIONS
+      false
+    end
+    alias_method_chain :set, :rescue
+
+    def add_with_rescue(*args)
+      add_without_rescue(*args)
+    rescue *NONFATAL_EXCEPTIONS
+      @string_return_types? "NOT STORED\r\n" : true
+    end
+    alias_method_chain :add, :rescue
+
+    %w{get delete incr decr append prepend}.each do |meth|
+      class_eval <<-ENV
+        def #{meth}_with_rescue(*args)
+          #{meth}_without_rescue(*args)
+        rescue *NONFATAL_EXCEPTIONS
+        end
+        alias_method_chain :#{meth}, :rescue
+      ENV
+    end
+  end
+end

data/lib/memcached_store/version.rb

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

data/memcached_store.gemspec

@@ -0,0 +1,27 @@
+# encoding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require "memcached_store/version"
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Camilo Lopez", "Tom Burns", "Arthur Neves"]
+  gem.email         = ["camilo@camilolopez.com", "tom.burns@shopify.com", "arthurnn@gmail.com"]
+  gem.summary = gem.description   = %q{Plugin-able Memcached adapters to add features (compression, safety)}
+  gem.homepage      = "https://github.com/Shopify/memcached_store/"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "memcached_store"
+  gem.require_paths = ["lib"]
+  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_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

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

data/test/test_memcached_safety.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+class TestMemcachedSafety < ActiveSupport::TestCase
+  setup do
+    @cache = MemcachedStore::MemcachedSafety.new(["localhost:21211"])
+    @entry = ActiveSupport::Cache::Entry.new({:omg => "ponies"})
+  end
+
+  test "exist? absorbs non-fatal exceptions" do
+    expect_nonfatal(:exist_without_rescue?)
+    @cache.exist?("a-key")
+  end
+
+  test "exist? raises fatal exceptions" do
+    expect_fatal(:exist_without_rescue?)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.exist?("a-key")
+    end
+  end
+
+  test "cas absorbs non-fatal exceptions" do
+    expect_nonfatal(:cas_without_rescue)
+    @cache.cas("a-key") { 1 }
+  end
+
+  test "cas raises fatal exceptions" do
+    expect_fatal(:cas_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.cas("a-key") { 1 }
+    end
+  end
+
+  test "get_multi absorbs non-fatal exceptions" do
+    expect_nonfatal(:get_multi_without_rescue)
+    @cache.get_multi(["a-key"])
+  end
+
+  test "get_multi raises fatal exceptions" do
+    expect_fatal(:get_multi_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.get_multi(["a-key"])
+    end
+  end
+
+  test "set absorbs non-fatal exceptions" do
+    expect_nonfatal(:set_without_rescue)
+    @cache.set("a-key", @entry)
+  end
+
+  test "set raises fatal exceptions" do
+    expect_fatal(:set_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.set("a-key", @entry)
+    end
+  end
+
+  test "add absorbs non-fatal exceptions" do
+    expect_nonfatal(:add_without_rescue)
+    @cache.add("a-key", "val")
+  end
+
+  test "add raises fatal exceptions" do
+    expect_fatal(:add_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.add("a-key", "val")
+    end
+  end
+
+  test "delete absorbs non-fatal exceptions" do
+    expect_nonfatal(:delete_without_rescue)
+    @cache.delete("a-key")
+  end
+
+  test "delete raises fatal exceptions" do
+    expect_fatal(:delete_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.delete("a-key")
+    end
+  end
+
+  test "incr absorbs non-fatal exceptions" do
+    expect_nonfatal(:incr_without_rescue)
+    @cache.incr("a-key")
+  end
+
+  test "incr raises fatal exceptions" do
+    expect_fatal(:incr_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.incr("a-key")
+    end
+  end
+
+  test "decr absorbs non-fatal exceptions" do
+    expect_nonfatal(:decr_without_rescue)
+    @cache.decr("a-key")
+  end
+
+  test "decr raises fatal exceptions" do
+    expect_fatal(:decr_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.decr("a-key")
+    end
+  end
+
+  test "append absorbs non-fatal exceptions" do
+    expect_nonfatal(:append_without_rescue)
+    @cache.append("a-key", "other")
+  end
+
+  test "append raises fatal exceptions" do
+    expect_fatal(:append_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.append("a-key", "other")
+    end
+  end
+
+  test "prepend absorbs non-fatal exceptions" do
+    expect_nonfatal(:prepend_without_rescue)
+    @cache.prepend("a-key", "other")
+  end
+
+  test "prepend raises fatal exceptions" do
+    expect_fatal(:prepend_without_rescue)
+    assert_raises(Memcached::AKeyLengthOfZeroWasProvided) do
+      @cache.prepend("a-key", "other")
+    end
+  end
+  private
+
+  def expect_nonfatal(sym)
+    MemcachedStore::MemcachedSafety.any_instance.expects(sym).raises(Memcached::ServerIsMarkedDead)
+  end
+
+  def expect_fatal(sym)
+    MemcachedStore::MemcachedSafety.any_instance.expects(sym).raises(Memcached::AKeyLengthOfZeroWasProvided)
+  end
+end

data/test/test_memcached_snappy_store.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+class TestMemcachedSnappyStore < ActiveSupport::TestCase
+
+  setup do
+     @cache = ActiveSupport::Cache.lookup_store(:memcached_snappy_store, Memcached::Rails.new(["localhost:11211"]))
+     @cache.clear
+  end
+
+  test "test should not allow increment" do
+    assert_raise(ActiveSupport::Cache::MemcachedSnappyStore::UnsupportedOperation) do
+      @cache.increment('foo')
+    end
+  end
+
+  test "should not allow decrement" do
+    assert_raise(ActiveSupport::Cache::MemcachedSnappyStore::UnsupportedOperation) do
+      @cache.decrement('foo')
+    end
+  end
+
+  test "write should not allow  the implicit add operation when unless_exist is passed to write" do
+    assert_raise(ActiveSupport::Cache::MemcachedSnappyStore::UnsupportedOperation) do
+      @cache.write('foo', 'bar', :unless_exist => true)
+    end
+  end
+
+  test "should use snappy to write cache entries" do
+    # Freezing time so created_at is the same in entry and the entry created
+    # internally and assert_equal between the raw data in the cache and the
+    # compressed explicitly makes sense
+    Timecop.freeze do
+      entry_value = { :omg => 'data' }
+      entry = ActiveSupport::Cache::Entry.new(entry_value)
+      key = 'moarponies'
+      assert @cache.write(key, entry_value)
+
+      serialized_entry = Marshal.dump(entry)
+      serialized_compressed_entry = Snappy.deflate(serialized_entry)
+      actual_cache_value = @cache.instance_variable_get(:@data).get(key, true)
+
+      assert_equal serialized_compressed_entry, actual_cache_value
+    end
+  end
+
+  test "should use snappy to read cache entries" do
+    entry_value = { :omg => 'data' }
+    key = 'ponies'
+
+    @cache.write(key, entry_value)
+    cache_entry = ActiveSupport::Cache::Entry.new(entry_value)
+    serialized_cached_entry =  Marshal.dump(cache_entry)
+
+    Snappy.expects(:inflate).returns(serialized_cached_entry)
+    assert_equal entry_value, @cache.read(key)
+  end
+
+  test "should skip snappy to reading not found" do
+    key = 'ponies2'
+    Snappy.expects(:inflate).never
+    assert_nil @cache.read(key)
+  end
+
+  test "should use snappy to multi read cache entries but not on missing entries" do
+    keys = %w{ one tow three }
+    values = keys.map{ |k| k * 10 }
+    entries = values.map{ |v| ActiveSupport::Cache::Entry.new(v) }
+
+    keys.each_with_index{ |k, i| @cache.write(k, values[i]) }
+
+    keys_and_missing = keys << 'missing'
+
+    Snappy.expects(:inflate).times(3).returns(*entries)
+    assert_equal values, @cache.read_multi(*keys_and_missing).values
+  end
+
+  test "should use snappy to multi read cache entries" do
+    keys = %w{ one tow three }
+    values = keys.map{ |k| k * 10 }
+    entries = values.map{ |v| ActiveSupport::Cache::Entry.new(v) }
+
+    keys.each_with_index{ |k, i| @cache.write(k, values[i]) }
+
+    Snappy.expects(:inflate).times(3).returns(*entries)
+    assert_equal values, @cache.read_multi(*keys).values
+  end
+
+  test "should support raw writes that don't use marshal format" do
+    key = 'key'
+    @cache.write(key, 'value', :raw => true)
+
+    actual_cache_value = @cache.instance_variable_get(:@data).get(key, true)
+    assert_equal 'value', Snappy.inflate(actual_cache_value)
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: memcached_store
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Camilo Lopez
+- Tom Burns
+- Arthur Neves
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: snappy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: i18n
+  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: rake
+  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: minitest
+  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: mocha
+  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: timecop
+  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: 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
+- tom.burns@shopify.com
+- arthurnn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/active_support/cache/memcached_snappy_store.rb
+- lib/memcached_store.rb
+- lib/memcached_store/memcached_safety.rb
+- lib/memcached_store/version.rb
+- memcached_store.gemspec
+- test/test_helper.rb
+- test/test_memcached_safety.rb
+- test/test_memcached_snappy_store.rb
+homepage: https://github.com/Shopify/memcached_store/
+licenses: []
+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.0
+signing_key: 
+specification_version: 4
+summary: Plugin-able Memcached adapters to add features (compression, safety)
+test_files:
+- test/test_helper.rb
+- test/test_memcached_safety.rb
+- test/test_memcached_snappy_store.rb