memcached_store 0.12.8 → 1.0.0

data/.gitignore

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

data/.travis.yml

@@ -1,16 +0,0 @@
-language: ruby
-services: memcache
-before_install:
-  - gem update bundler
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - 2.1.1
-env:
-  - "AS_VERSION=3.2.18"
-  - "AS_VERSION=4.0.5"
-  - "AS_VERSION=4.1.0"
-matrix:
-  allow_failures:
-    - env: "AS_VERSION=4.1.0"

data/Gemfile

@@ -1,21 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in rails_cache_adapters.gemspec
-gemspec
-
-version = ENV["AS_VERSION"] || "4.0.5"
-as_version = case version
-when "master"
-  {:github => "rails/rails"}
-else
-  "~> #{version}"
-end
-
-gem "activesupport", as_version
-
-group :test do
-  gem "minitest", '~> 4.0' if version == "3.2.18"
-  gem "mocha"
-  gem "timecop"
-  gem "snappy"
-end

data/Rakefile

@@ -1,21 +0,0 @@
-require 'bundler/gem_tasks'
-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 :tag => :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"
-end

data/lib/memcached_store/memcached_safety.rb

@@ -1,88 +0,0 @@
-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
-      report_exception($!)
-    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
-      report_exception($!)
-      false
-    end
-    alias_method_chain :cas, :rescue
-
-    def get_multi_with_rescue(*args)
-      get_multi_without_rescue(*args)
-    rescue *NONFATAL_EXCEPTIONS
-      report_exception($!)
-      {}
-    end
-    alias_method_chain :get_multi, :rescue
-
-    def set_with_rescue(*args)
-      set_without_rescue(*args)
-    rescue *NONFATAL_EXCEPTIONS
-      report_exception($!)
-      false
-    end
-    alias_method_chain :set, :rescue
-
-    def add_with_rescue(*args)
-      add_without_rescue(*args)
-    rescue *NONFATAL_EXCEPTIONS
-      report_exception($!)
-      @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
-          report_exception($!)
-        end
-        alias_method_chain :#{meth}, :rescue
-      ENV
-    end
-
-    def logger
-      return @logger if @logger
-      @logger = ::Rails.logger if defined?(::Rails)
-    end
-
-    private
-
-    def report_exception(exception)
-      if defined?(::Rails)
-        logger.error "[#{self.class}] exception=#{exception}"
-      end
-      nil # make sure return value is nil
-    end
-  end
-end

data/memcached_store.gemspec

@@ -1,22 +0,0 @@
-# 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", "Francis Bogsanyi"]
-  gem.email         = ["camilo@camilolopez.com", "tom.burns@shopify.com", "arthurnn@gmail.com", "francis.bogsanyi@shopify.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 "memcached", "~> 1.8.0"
-
-  gem.add_development_dependency "rake"
-end

data/shipit.rubygems.yml

@@ -1,4 +0,0 @@
-dependencies:
-  bundler:
-    without:
-      - test

data/test/test_helper.rb

@@ -1,21 +0,0 @@
-require 'minitest/autorun'
-require 'mocha/setup'
-require 'timecop'
-
-require 'active_support/test_case'
-
-require 'memcached_store'
-
-class Rails
-  def self.logger
-    @logger ||= Logger.new("/dev/null")
-  end
-
-  def self.env
-    Struct.new("Env") do
-      def self.test?
-        true
-      end
-    end
-  end
-end

data/test/test_memcached_safety.rb

@@ -1,142 +0,0 @@
-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
-
-  test "logger defaults to rails logger" do
-    assert_equal Rails.logger, @cache.logger
-  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

@@ -1,172 +0,0 @@
-require 'test_helper'
-
-class TestMemcachedSnappyStore < ActiveSupport::TestCase
-
-  setup do
-     @cache = ActiveSupport::Cache.lookup_store(:memcached_snappy_store, support_cas: true)
-     @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 allow  the implicit add operation when unless_exist is passed to write" do
-    assert_nothing_raised(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 "get should work when there is a connection fail" do
-    key = 'ponies2'
-    @cache.instance_variable_get(:@data).expects(:check_return_code).raises(Memcached::ConnectionFailure).at_least_once
-    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
-
-  test "cas should use snappy to read and write cache entries" do
-    entry_value = { :omg => 'data' }
-    update_value = 'value'
-    key = 'ponies'
-
-    @cache.write(key, entry_value)
-    result = @cache.cas(key) do |v|
-      assert_equal entry_value, v
-      update_value
-    end
-    assert result
-    assert_equal update_value, @cache.read(key)
-
-    actual_cache_value = @cache.instance_variable_get(:@data).get(key, true)
-    serialized_entry = Snappy.inflate(actual_cache_value)
-    entry = Marshal.load(serialized_entry)
-    assert entry.is_a?(ActiveSupport::Cache::Entry)
-    assert_equal update_value, entry.value
-  end
-
-  test "cas should support raw entries that don't use marshal format" do
-    key = 'key'
-    @cache.write(key, 'value', :raw => true)
-    result = @cache.cas(key, :raw => true) do |v|
-      assert_equal 'value', v
-      'new_value'
-    end
-    assert result
-    actual_cache_value = @cache.instance_variable_get(:@data).get(key, true)
-    assert_equal 'new_value', Snappy.inflate(actual_cache_value)
-  end
-
-  test "cas_multi should use snappy to read and write cache entries" do
-    keys = %w{ one two three four }
-    values = keys.map{ |k| k * 10 }
-    update_hash = Hash[keys.drop(1).map {|k| [k, k * 11] }]
-
-    keys.zip(values) { |k, v| @cache.write(k, v) }
-
-    result = @cache.cas_multi(*keys) do |hash|
-      assert_equal Hash[keys.zip(values)], hash
-      update_hash
-    end
-    assert result
-    assert_equal Hash[keys.zip(values)].merge(update_hash), @cache.read_multi(*keys)
-
-    update_hash.each do |key, value|
-      actual_cache_value = @cache.instance_variable_get(:@data).get(key, true)
-      serialized_entry = Snappy.inflate(actual_cache_value)
-      entry = Marshal.load(serialized_entry)
-      assert entry.is_a?(ActiveSupport::Cache::Entry)
-      assert_equal value, entry.value
-    end
-  end
-
-  test "cas_multi should support raw entries that don't use marshal format" do
-    keys = %w{ one two three }
-    values = keys.map{ |k| k * 10 }
-    update_hash = {"two" => "two" * 11}
-
-    keys.zip(values) { |k, v| @cache.write(k, v) }
-
-    result = @cache.cas_multi(*keys, :raw => true) do |hash|
-      assert_equal Hash[keys.zip(values)], hash
-      update_hash
-    end
-    assert result
-    actual_cache_value = @cache.instance_variable_get(:@data).get("two", true)
-    assert_equal update_hash["two"], Snappy.inflate(actual_cache_value)
-  end
-end