memcache 1.3.0 → 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 825860f91b9b3291cc74c1f735661c2bc9031d43
+  data.tar.gz: 20397ed826b4973ff8662c00c4dac90ca528d7cd
+SHA512:
+  metadata.gz: 6c086c05cf5f57dbdd525558e38f859776c589fca4b25a01826a504c0cef6c3e525723aac4dbd5daa596c3c5ef4d2c00153e1d4a75b705d1a3817b32fb512cfe
+  data.tar.gz: 9c568fdbb4bdb0ca8e8e22be657fba9e56373dc926c547a9066ee2e0dc268d61a576c780f1221e8dde4d244c2bc3371cbce8af4dc9eb3b9c966aa7a73264c19b

data/.rbenv-version

@@ -1 +1 @@
-ree-1.8.7-2012.02
+2.0.0-p247

data/VERSION

@@ -1 +1 @@
-1.3.0
+1.4.0

data/ext/native_server.c

@@ -20,6 +20,9 @@ VALUE sym_binary;
 VALUE sym_servers;
 VALUE sym_ketama;
 VALUE sym_ketama_weighted;
+VALUE sym_value;
+VALUE sym_flags;
+VALUE sym_cas;
 
 ID id_default;
 ID id_md5;
@@ -36,8 +39,6 @@ ID id_consistent;
 ID id_ketama;
 ID id_ketama_spy;
 
-static ID iv_memcache_flags, iv_memcache_cas;
-
 static void mc_free(void *p) {
   memcached_free(p);
 }
@@ -83,7 +84,7 @@ static memcached_hash_t hash_behavior(VALUE sym) {
   rb_raise(cMemcacheError, "Invalid hash behavior");
 }
 
-static memcached_hash_t distribution_behavior(VALUE sym) {
+static memcached_server_distribution_t distribution_behavior(VALUE sym) {
   ID id = SYM2ID(sym);
 
   if (id == id_modula     ) return MEMCACHED_DISTRIBUTION_MODULA;
@@ -241,7 +242,7 @@ static bool use_binary(memcached_st* mc) {
 
 static VALUE mc_get(int argc, VALUE *argv, VALUE self) {
   memcached_st *mc;
-  VALUE cas, keys, results, key, value;
+  VALUE cas, keys, results, key, result;
   VALUE scalar_key = Qnil;
   memcached_return status;
 
@@ -264,16 +265,17 @@ static VALUE mc_get(int argc, VALUE *argv, VALUE self) {
     if (str == NULL) return Qnil;
 
     if (status == MEMCACHED_SUCCESS) {
-      value = rb_str_new(str, len);
-      rb_ivar_set(value, iv_memcache_flags, INT2NUM(flags));
+      result = rb_hash_new();
+      rb_hash_aset(result, sym_value, rb_str_new(str, len));
+      rb_hash_aset(result, sym_flags, INT2NUM(flags));
       free(str);
-      return value;
+      return result;
     } else {
       printf("Memcache read error: %s %u\n", memcached_strerror(mc, status), status);
       return Qnil;
     }
   } else {
-    memcached_result_st* result;
+    memcached_result_st* mc_result;
     size_t       num_keys, i;
     const char** key_strings;
     size_t*      key_lengths;
@@ -295,19 +297,21 @@ static VALUE mc_get(int argc, VALUE *argv, VALUE self) {
 
     memcached_mget(mc, key_strings, key_lengths, num_keys);
 
-    while (result = memcached_fetch_result(mc, NULL, &status)) {
+    while ((mc_result = memcached_fetch_result(mc, NULL, &status))) {
       if (escaped) {
-        key = unescape_key(memcached_result_key_value(result), memcached_result_key_length(result));
+        key = unescape_key(memcached_result_key_value(mc_result), memcached_result_key_length(mc_result));
       } else {
-        key = rb_str_new(memcached_result_key_value(result), memcached_result_key_length(result));
+        key = rb_str_new(memcached_result_key_value(mc_result), memcached_result_key_length(mc_result));
       }
 
       if (status == MEMCACHED_SUCCESS) {
-        value = rb_str_new(memcached_result_value(result), memcached_result_length(result));
-        rb_ivar_set(value, iv_memcache_flags, INT2NUM(memcached_result_flags(result)));
-        if (RTEST(cas)) rb_ivar_set(value, iv_memcache_cas, ULL2NUM(memcached_result_cas(result)));
-        memcached_result_free(result);
-        rb_hash_aset(results, key, value);
+        result = rb_hash_new();
+        rb_hash_aset(result, sym_value, rb_str_new(memcached_result_value(mc_result),
+                                                   memcached_result_length(mc_result)));
+        rb_hash_aset(result, sym_flags, INT2NUM(memcached_result_flags(mc_result)));
+        if (RTEST(cas)) rb_hash_aset(result, sym_cas, ULL2NUM(memcached_result_cas(mc_result)));
+        memcached_result_free(mc_result);
+        rb_hash_aset(results, key, result);
       } else {
         printf("Memcache read error: %s %u\n", memcached_strerror(mc, status), status);
       }
@@ -590,9 +594,9 @@ void Init_native_server() {
   sym_servers          = ID2SYM(rb_intern("servers"));
   sym_ketama           = ID2SYM(rb_intern("ketama"));
   sym_ketama_weighted  = ID2SYM(rb_intern("ketama_weighted"));
-
-  iv_memcache_flags = rb_intern("@memcache_flags");
-  iv_memcache_cas   = rb_intern("@memcache_cas");
+  sym_value            = ID2SYM(rb_intern("value"));
+  sym_flags            = ID2SYM(rb_intern("flags"));
+  sym_cas              = ID2SYM(rb_intern("cas"));
 
   id_default    = rb_intern("default");
   id_md5        = rb_intern("md5");

data/lib/memcache.rb

@@ -106,21 +106,24 @@ class Memcache
 
   def get(keys, opts = {})
     raise 'opts must be hash' unless opts.instance_of?(Hash)
-
     if keys.instance_of?(Array)
       keys = keys.collect {|key| key.to_s}
       multi_get(keys, opts)
     else
       key = keys.to_s
       if opts[:expiry]
-        value = server(key).gets(key)
-        cas(key, value, :raw => true, :cas => value.memcache_cas, :expiry => opts[:expiry]) if value
+        result = server(key).gets(key)
+        cas(key, result[:value], :raw => true, :cas => result[:cas], :expiry => opts[:expiry]) if result
       else
-        value = server(key).get(key, opts[:cas])
+        result = server(key).get(key, opts[:cas])
       end
 
-      return backup.get(key, opts) if backup and value.nil?
-      opts[:raw] ? value : unmarshal(value, key)
+      if result
+        result[:value] = unmarshal(result[:value], key) unless opts[:raw]
+        opts[:meta] ? result : result[:value]
+      elsif backup
+        backup.get(key, opts)
+      end
     end
   end
 
@@ -217,53 +220,54 @@ class Memcache
   end
 
   def update(key, opts = {})
-    key   = key.to_s
-    value = get(key, :cas => true)
-    if value
-      cas(key, yield(value), opts.merge!(:cas => value.memcache_cas))
+    key    = key.to_s
+    result = get(key, :cas => true, :meta => true)
+    if result
+      cas(key, yield(result[:value]), opts.merge!(:cas => result[:cas]))
     else
-      add(key, yield(value), opts)
+      add(key, yield(result[:value]), opts)
     end
   end
 
-  def get_or_add(key, *args)
+  def get_or_add(key, *args, &block)
     # Pseudo-atomic get and update.
     key = key.to_s
-    if block_given?
+    if block
       opts = args[0] || {}
-      get(key) || add(key, yield, opts) || get(key)
     else
       opts = args[1] || {}
-      get(key) || add(key, args[0], opts) || get(key)
+      block = lambda { args[0] }
     end
+    get(key, opts) || add(key, block.call(), opts) || get(key, opts)
   end
 
-  def get_or_set(key, *args)
+  def get_or_set(key, *args, &block)
     key = key.to_s
     if block_given?
       opts = args[0] || {}
-      get(key) || set(key, yield, opts)
     else
       opts = args[1] || {}
-      get(key) || set(key, args[0], opts)
+      block = lambda { args[0] }
     end
+    get(key, opts) || set(key, block.call(), opts)
   end
 
   def add_or_get(key, value, opts = {})
     # Try to add, but if that fails, get the existing value.
-    add(key, value, opts) || get(key)
+    add(key, value, opts) || get(key, opts)
   end
 
   def get_some(keys, opts = {})
-    keys = keys.collect {|key| key.to_s}
-    records = opts[:disable] ? {} : self.multi_get(keys, opts)
+    keys    = keys.collect {|key| key.to_s}
+    results = opts[:disable] ? {} : self.multi_get(keys, opts)
     if opts[:validation]
-      records.delete_if do |key, value|
+      results.delete_if do |key, result|
+        value = opts[:meta] ? result[:value] : result
         not opts[:validation].call(key, value)
       end
     end
 
-    keys_to_fetch = keys - records.keys
+    keys_to_fetch = keys - results.keys
     if keys_to_fetch.any?
       yield(keys_to_fetch).each do |key, value|
         begin
@@ -272,10 +276,10 @@ class Memcache
           raise if opts[:strict_write]
           $stderr.puts "Memcache error in get_some: #{e.class} #{e.to_s} on key '#{key}' while storing value: #{value}"
         end
-        records[key] = value
+        results[key] = opts[:meta] ? {:value => value} : value
       end
     end
-    records
+    results
   end
 
   def lock(key, opts = {})
@@ -385,8 +389,9 @@ protected
 
     results = {}
     fetch_results = lambda do |server, keys|
-      server.get(keys, opts[:cas]).each do |key, value|
-        results[key] = opts[:raw] ? value : unmarshal(value, key)
+      server.get(keys, opts[:cas]).each do |key, result|
+        result[:value] = unmarshal(result[:value], key) unless opts[:raw]
+        results[key] = opts[:meta] ? result : result[:value]
       end
     end
 
@@ -419,11 +424,7 @@ protected
 
   def unmarshal(value, key = nil)
     return value if value.nil?
-
-    object = Marshal.load(value)
-    object.memcache_flags = value.memcache_flags
-    object.memcache_cas   = value.memcache_cas
-    object
+    Marshal.load(value)
   rescue Exception => e
     $stderr.puts "Memcache read error: #{e.class} #{e.to_s} on key '#{key}' while unmarshalling value: #{value}"
     $stderr.puts caller
@@ -472,8 +473,3 @@ protected
     @@cache_pool ||= Pool.new
   end
 end
-
-# Add flags and cas
-class Object
-  attr_accessor :memcache_flags, :memcache_cas
-end

data/lib/memcache/base.rb

@@ -13,8 +13,10 @@ class Memcache
     end
 
     def incr(key, amount = 1)
-      value = get(key)
-      return unless value
+      result = get(key)
+      return unless result
+
+      value = result[:value]
       return unless value =~ /^\d+$/
 
       value = value.to_i + amount
@@ -45,13 +47,13 @@ class Memcache
     def append(key, value)
       existing = get(key)
       return false if existing.nil?
-      set(key, existing + value) && true
+      set(key, existing[:value] + value) && true
     end
 
     def prepend(key, value)
       existing = get(key)
       return false if existing.nil?
-      set(key, value + existing) && true
+      set(key, value + existing[:value]) && true
     end
 
   protected

data/lib/memcache/local_server.rb

@@ -1,7 +1,7 @@
 class Memcache
   class LocalServer < Base
     def initialize
-      @data = {}
+      @data   = {}
       @expiry = {}
     end
 
@@ -26,9 +26,9 @@ class Memcache
       if keys.kind_of?(Array)
         hash = {}
         keys.each do |key|
-          key = key.to_s
-          val = get(key)
-          hash[key] = val if val
+          key    = key.to_s
+          result = get(key)
+          hash[key] = result if result
         end
         hash
       else
@@ -43,7 +43,7 @@ class Memcache
 
     def set(key, value, expiry = 0, flags = 0)
       key = cache_key(key)
-      @data[key] = value.to_s
+      @data[key] = {:value => value.to_s, :flags => flags}
       expiry = Time.at(expiry) if expiry > 60*60*24*30
       if expiry.kind_of?(Time)
         @expiry[key] = expiry

data/lib/memcache/migration.rb

@@ -9,6 +9,7 @@ class Memcache
         t.string    :prefix, :null => false
         t.string    :key,    :null => false
         t.text      :value,  :null => false
+        t.integer   :flags
         t.timestamp :expires_at
         t.timestamp :updated_at
       end

data/lib/memcache/pg_server.rb

@@ -28,27 +28,30 @@ class Memcache
       db.exec("TRUNCATE #{table}")
     end
 
-    def get(keys)
+    def get(keys, cas = false)
+      # cas ignored for now
       return get([keys])[keys.to_s] unless keys.kind_of?(Array)
       return {} if keys.empty?
 
       keys = keys.collect {|key| quote(key.to_s)}.join(',')
       sql = %{
-        SELECT key, value FROM #{table}
+        SELECT key, value, flags FROM #{table}
           WHERE key IN (#{keys}) AND #{prefix_clause} AND #{expiry_clause}
       }
 
       results = {}
       db.query(sql).each do |row|
-        results[row['key']] = row['value']
+        results[row['key']] = {:value => row['value'], :flags => row['flags'].to_i}
       end
       results
     end
 
     def incr(key, amount = 1)
       transaction do
-        value = get(key)
-        return unless value
+        result = get(key)
+        return unless result
+
+        value = result[:value]
         return unless value =~ /^\d+$/
 
         value = value.to_i + amount
@@ -73,25 +76,25 @@ class Memcache
       result.cmdtuples == 1
     end
 
-    def set(key, value, expiry = 0)
+    def set(key, value, expiry = 0, flags = 0)
       transaction do
         delete(key)
-        insert(key, value, expiry)
+        insert(key, value, expiry, flags)
       end
       value
     end
 
-    def add(key, value, expiry = 0)
+    def add(key, value, expiry = 0, flags = 0)
       delete_expired(key)
-      insert(key, value, expiry)
+      insert(key, value, expiry, flags)
       value
     rescue PGError => e
       nil
     end
 
-    def replace(key, value, expiry = 0)
+    def replace(key, value, expiry = 0, flags = 0)
       delete_expired(key)
-      result = update(key, value, expiry)
+      result = update(key, value, expiry, flags)
       result.cmdtuples == 1 ? value : nil
     end
 
@@ -117,17 +120,20 @@ class Memcache
 
   private
 
-    def insert(key, value, expiry = 0)
+    def insert(key, value, expiry, flags)
       db.exec %{
-        INSERT INTO #{table} (prefix, key, value, updated_at, expires_at)
-          VALUES (#{quoted_prefix}, #{quote(key)}, #{quote(value)}, NOW(), #{expiry_sql(expiry)})
+        INSERT INTO #{table} (prefix, key, value, flags, updated_at, expires_at)
+          VALUES (#{quoted_prefix}, #{quote(key)}, #{quote(value)}, #{flags.to_i}, NOW(), #{expiry_sql(expiry)})
       }
     end
 
-    def update(key, value, expiry = 0)
+    def update(key, value, expiry, flags)
       db.exec %{
         UPDATE #{table}
-          SET value = #{quote(value)}, updated_at = NOW(), expires_at = #{expiry_sql(expiry)}
+          SET value = #{quote(value)}, 
+              flags = #{flags.to_i},
+              updated_at = NOW(),
+              expires_at = #{expiry_sql(expiry)}
           WHERE key = #{quote(key)} AND #{prefix_clause}
       }
     end

data/lib/memcache/segmented.rb

@@ -12,9 +12,9 @@ class Memcache
       results = super(keys, cas)
       keys = {}
       keys_to_fetch = []
-      results.each do |key, value|
-        next unless segmented?(value)
-        keys[key] = segment_keys(value)
+      results.each do |key, result|
+        next unless segmented?(result)
+        keys[key] = segment_keys(result)
         keys_to_fetch.concat keys[key]
       end
 
@@ -22,7 +22,7 @@ class Memcache
       keys.each do |key, hashes|
         value = ''
         hashes.each do |hash_key|
-          if part = parts[hash_key]
+          if part = parts[hash_key][:value]
             value << part
           else
             value = nil
@@ -30,11 +30,8 @@ class Memcache
           end
         end
 
-        if value
-          value.memcache_cas   = results[key].memcache_cas
-          value.memcache_flags = results[key].memcache_flags ^ PARTIAL_VALUE
-        end
-        results[key] = value
+        results[key][:value] = value
+        results[key][:flags] ^= PARTIAL_VALUE
       end
       results
     end
@@ -66,18 +63,18 @@ class Memcache
     end
 
     def delete(key)
-      value  = super_get(key)
-      result = block_given? ? yield : super
-      if result and segmented?(value)
-        segment_keys(value).each {|k| super(k)}
+      result = super_get(key)
+      enable = block_given? ? yield : super
+      if enable and result and segmented?(result)
+        segment_keys(result).each {|k| super(k)}
       end
-      result
+      enable
     end
 
   private
 
-    def segmented?(value)
-      value.memcache_flags & PARTIAL_VALUE == PARTIAL_VALUE
+    def segmented?(result)
+      result[:flags] & PARTIAL_VALUE == PARTIAL_VALUE
     end
 
     def segment(key, value)
@@ -105,8 +102,8 @@ class Memcache
       end
     end
 
-    def segment_keys(value)
-      hash, num = value.split(':')
+    def segment_keys(result)
+      hash, num = result[:value].split(':')
       (0...num.to_i).collect {|i| "#{hash}:#{i}"}
     end
 

data/lib/memcache/server.rb

@@ -94,11 +94,14 @@ class Memcache
         value = socket.read(length.to_i)
         match_response!(socket.read(2), "\r\n")
 
-        value.memcache_flags = flags.to_i
-        value.memcache_cas   = cas
+        result = {
+          :value => value,
+          :flags => flags.to_i,
+        }
+        result[:cas] = cas if cas
 
         key = input_key(key)
-        results[key] = value
+        results[key] = result
       end
       results
     end

data/memcache.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |gem|
   gem.description   = %q{Ruby client for memcached supporting advanced protocol features and pluggable architecture.}
   gem.summary       = gem.description
   gem.homepage      = "https://github.com/ninjudd/memcache"
+  gem.license       = 'MIT'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'shoulda', '3.0.1'
@@ -20,4 +21,5 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+  gem.extensions    = ["ext/extconf.rb"]
 end

data/test/memcache_local_server_test.rb

@@ -1,4 +1,4 @@
-require 'memcache_server_test_helper'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
 
 class MemcacheLocalServerTest < Test::Unit::TestCase
   include MemcacheServerTestHelper

data/test/memcache_native_server_test.rb

@@ -1,4 +1,4 @@
-require 'memcache_server_test_helper'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
 
 class MemcacheNativeServerTest < Test::Unit::TestCase
   include MemcacheServerTestHelper
@@ -27,6 +27,6 @@ class MemcacheNativeServerTest < Test::Unit::TestCase
     m.close
 
     m.set('foo', 'foo')
-    assert_equal 'foo', m.get('foo')
+    assert_equal 'foo', m.get('foo')[:value]
   end
 end

data/test/memcache_pg_server_test.rb

@@ -1,4 +1,4 @@
-require 'memcache_server_test_helper'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
 require 'memcache/pg_server'
 
 class MemcachePGServerTest < Test::Unit::TestCase

data/test/memcache_segmented_test_helper.rb

@@ -8,7 +8,7 @@ module MemcacheSegmentedTestHelper
     assert_not_equal '1,2,3,4,5,6,7,8,9,10', master_key
     assert_equal 7, segment_keys.size
 
-    assert_equal '1,2,3,4,5,6,7,8,9,10', m.get('fav_numbers')
+    assert_equal '1,2,3,4,5,6,7,8,9,10', m.get('fav_numbers')[:value]
     assert_equal true, m.delete('fav_numbers')
     assert_equal nil, m.get('fav_numbers')
 

data/test/memcache_server_test.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'memcache_server_test_helper'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
 
 class MemcacheServerTest < Test::Unit::TestCase
   include MemcacheServerTestHelper

data/test/memcache_server_test_helper.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 
 module MemcacheServerTestHelper
   def test_prefix
@@ -14,8 +14,8 @@ module MemcacheServerTestHelper
 
     m.set('2', 'foo', 0)
     assert_equal nil,   m.get('1')
-    assert_equal 'foo', m.get('2')
-    assert_equal({'2'=>'foo'}, m.get(['1', '2']))
+    assert_equal 'foo', m.get('2')[:value]
+    assert_equal({'2' => {:value => 'foo', :flags => 0}}, m.get(['1', '2']))
 
     assert_equal 'bar:', m.prefix = 'bar:'
     assert_equal 'bar:', m.prefix
@@ -23,57 +23,58 @@ module MemcacheServerTestHelper
     assert_equal nil, m.prefix = nil
     assert_equal nil, m.prefix
 
-    assert_equal 'baz', m.get('1')
-    assert_equal 'bar', m.get('2')
-    assert_equal({'1'=>'baz','2'=>'bar'}, m.get(['1', '2']))
+    assert_equal 'baz', m.get('1')[:value]
+    assert_equal 'bar', m.get('2')[:value]
+    assert_equal({'1' => {:value => 'baz', :flags => 0},
+                  '2' => {:value => 'bar', :flags => 0}}, m.get(['1', '2']))
   end
 
   def test_set_and_get
     assert_equal 'foo', m.set('2', 'foo', 0)
 
-    assert_equal 'foo', m.get('2')
-    assert_equal 'foo', m.get('2')
+    assert_equal 'foo', m.get('2')[:value]
+    assert_equal 'foo', m.get('2')[:value]
 
     assert_equal 'bar', m.set('2', 'bar', 0)
 
-    assert_equal 'bar', m.get('2')
-    assert_equal 'bar', m.get('2')
+    assert_equal 'bar', m.get('2')[:value]
+    assert_equal 'bar', m.get('2')[:value]
   end
 
   def test_spaces_in_keys
     assert_equal '1', m.set('foo bar', '1', 0)
 
-    assert_equal '1', m.get('foo bar')
-    assert_equal '1', m.get('foo bar')
+    assert_equal '1', m.get('foo bar')[:value]
+    assert_equal '1', m.get('foo bar')[:value]
 
     assert_equal '2', m.set('foo bar', '2', 0)
 
-    assert_equal '2', m.get('foo bar')
-    assert_equal '2', m.get('foo bar')
+    assert_equal '2', m.get('foo bar')[:value]
+    assert_equal '2', m.get('foo bar')[:value]
 
     assert_equal '8', m.set('foo baz', '8', 0)
 
-    expected = { 'foo bar' => '2', 'foo baz' => '8' }
-    assert_equal expected, m.get(['foo bar','foo baz'])
+    assert_equal({'foo bar' => {:value => '2', :flags => 0},
+                  'foo baz' => {:value => '8', :flags => 0}}, m.get(['foo bar','foo baz']))
 
     assert_equal 'foo', m.set(' ', 'foo', 0)
-    assert_equal 'foo', m.get(' ')
+    assert_equal 'foo', m.get(' ')[:value]
     assert_equal true, m.delete(' ')
   end
 
   def test_expiry
     assert_equal 'foo', m.set('foo', 'foo', 1)
-    assert_equal 'foo', m.get('foo')
+    assert_equal 'foo', m.get('foo')[:value]
 
     assert_equal 'bar', m.add('bar', 'bar', 1)
-    assert_equal 'bar', m.get('bar')
+    assert_equal 'bar', m.get('bar')[:value]
 
     assert_equal '',    m.set('baz', '')
     assert_equal 'baz', m.replace('baz', 'baz', 1)
-    assert_equal 'baz', m.get('baz')
+    assert_equal 'baz', m.get('baz')[:value]
 
     assert_equal 'bap', m.set('bam', 'bap', (Time.now + 1).to_i)
-    assert_equal 'bap', m.get('bam')
+    assert_equal 'bap', m.get('bam')[:value]
 
     sleep 2
 
@@ -90,13 +91,13 @@ module MemcacheServerTestHelper
 
     # Add should only work if key doesn't exist.
     assert_equal 'foo', m.add('foo', 'foo')
-    assert_equal 'foo', m.get('foo')
+    assert_equal 'foo', m.get('foo')[:value]
     assert_equal nil,   m.add('foo', 'bar')
-    assert_equal 'foo', m.get('foo')
+    assert_equal 'foo', m.get('foo')[:value]
 
     # Replace should only work if key doesn't exist.
     assert_equal 'bar', m.replace('foo', 'bar')
-    assert_equal 'bar', m.get('foo')
+    assert_equal 'bar', m.get('foo')[:value]
   end
 
   def test_append_and_prepend
@@ -105,10 +106,10 @@ module MemcacheServerTestHelper
 
     m.set('foo', 'foo')
     assert_equal true, m.append('foo', 'bar')
-    assert_equal 'foobar', m.get('foo')
+    assert_equal 'foobar', m.get('foo')[:value]
 
     assert_equal true, m.prepend('foo', 'baz')
-    assert_equal 'bazfoobar', m.get('foo')
+    assert_equal 'bazfoobar', m.get('foo')[:value]
   end
 
   def test_incr
@@ -121,33 +122,33 @@ module MemcacheServerTestHelper
 
     m.set('foo', '0')
     assert_equal 1, m.incr('foo')
-    assert_equal '1', m.get('foo')
+    assert_equal '1', m.get('foo')[:value]
 
     assert_equal 53, m.incr('foo', 52)
-    assert_equal '53', m.get('foo')
+    assert_equal '53', m.get('foo')[:value]
 
     assert_equal 10, m.decr('foo', 43)
-    assert_equal '10', m.get('foo')
+    assert_equal '10', m.get('foo')[:value]
 
     # Cannot go below zero.
     assert_equal 0, m.decr('foo', 100)
-    assert_equal '0', m.get('foo').strip
+    assert_equal '0', m.get('foo')[:value].strip
   end
 
   def test_multi_get
     m.set('2', '1,2,3')
     m.set('3', '4,5')
 
-    expected = { '2' => '1,2,3', '3' => '4,5' }
+    expected = { '2' => {:value => '1,2,3', :flags => 0}, '3' => {:value => '4,5', :flags => 0} }
     assert_equal expected, m.get(['2','3'])
-    assert_equal '4,5', m.get(['3'])['3']
+    assert_equal '4,5', m.get(['3'])['3'][:value]
     assert_equal({}, m.get([]))
   end
 
   def test_delete
     m.set('2', '1,2,3')
 
-    assert_equal '1,2,3', m.get('2')
+    assert_equal '1,2,3', m.get('2')[:value]
     assert_equal true, m.delete('2')
     assert_equal nil, m.get('2')
   end
@@ -155,7 +156,7 @@ module MemcacheServerTestHelper
   def test_flush_all
     m.set('2', 'bar')
 
-    assert_equal 'bar', m.get('2')
+    assert_equal 'bar', m.get('2')[:value]
 
     m.flush_all
 
@@ -165,39 +166,35 @@ module MemcacheServerTestHelper
   module AdvancedMethods
     def test_flags
       m.set('thom', 'hartmann', 0)
-      value = m.gets('thom')
-      assert_equal 0, value.memcache_flags
+      assert_equal 0, m.gets('thom')[:flags]
 
       m.set('thom', 'hartmann', 0, 0b11110001)
-      value = m.gets('thom')
-      assert_equal 0b11110001, value.memcache_flags
+      assert_equal 0b11110001, m.gets('thom')[:flags]
 
-      value = m.get('thom')
-      assert_equal 0b11110001, value.memcache_flags
+      assert_equal 0b11110001, m.get('thom')[:flags]
 
       m.set('thom', 'hartmann', 0, 0b10101010)
-      value = m.get('thom')
-      assert_equal 0b10101010, value.memcache_flags
+      assert_equal 0b10101010, m.get('thom')[:flags]
     end
 
     def test_gets_and_cas
       m.set('thom', 'hartmann')
 
-      value = m.gets('thom')
-      assert_equal 'hartmann', value
-      assert_equal 'thompson', m.cas('thom', 'thompson', value.memcache_cas)
-      assert_equal 'thompson', m.get('thom')
+      result = m.gets('thom')
+      assert_equal 'hartmann', result[:value]
+      assert_equal 'thompson', m.cas('thom', 'thompson', result[:cas])
+      assert_equal 'thompson', m.get('thom')[:value]
 
-      value = m.gets('thom')
+      result = m.gets('thom')
       m.delete('thom')
-      assert_nil m.cas('thom', 'hartson', value.memcache_cas)
+      assert_nil m.cas('thom', 'hartson', result[:cas])
       assert_equal nil, m.get('thom')
 
       m.add('thom', 'hartmann')
-      value = m.gets('thom')
+      result = m.gets('thom')
       m.set('thom', 'foo')
-      assert_nil m.cas('thom', 'hartson', value.memcache_cas)
-      assert_equal 'foo', m.get('thom')
+      assert_nil m.cas('thom', 'hartson', result[:cas])
+      assert_equal 'foo', m.get('thom')[:value]
     end
   end
 end

data/test/memcache_test.rb

@@ -17,6 +17,7 @@ class MemcacheTest < Test::Unit::TestCase
 
     keys = (0..200).collect {|key| key.to_s}
     results = m.get(keys)
+
     assert_equal 100, results.size
     results.each do |key, value|
       assert_equal key.to_i, value
@@ -242,10 +243,10 @@ class MemcacheTest < Test::Unit::TestCase
 
   def test_flags
     m.set('foo', :foo, :flags => 43)
-    assert_equal 43, m.get('foo').memcache_flags
+    assert_equal 43, m.get('foo', :meta => true)[:flags]
 
     m.set('foo', 'foo', :raw => true, :flags => 43)
-    assert_equal 43, m.get('foo', :raw => true).memcache_flags
+    assert_equal 43, m.get('foo', :raw => true, :meta => true)[:flags]
   end
 
   def test_clone

data/test/test_helper.rb

@@ -4,7 +4,6 @@ require 'shoulda'
 require 'mocha/setup'
 require 'pp'
 
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 require 'memcache'
 
 class Test::Unit::TestCase
@@ -41,7 +40,7 @@ class Test::Unit::TestCase
         prefixes.each do |prefix|
           assert_equal prefix, m.prefix = prefix
           assert_equal prefix, m.prefix
-          super
+          super()
           assert_equal nil, m.prefix = nil
           assert_equal nil, m.prefix
         end

metadata

@@ -1,105 +1,94 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: memcache
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: 
-  segments: 
-  - 1
-  - 3
-  - 0
-  version: 1.3.0
+version: !ruby/object:Gem::Version
+  version: 1.4.0
 platform: ruby
-authors: 
+authors:
 - Justin Balthrop
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-06-03 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: shoulda
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 3
-        - 0
-        - 1
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
         version: 3.0.1
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: activerecord
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: activerecord-postgresql-adapter
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-postgresql-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id005
-description: Ruby client for memcached supporting advanced protocol features and pluggable architecture.
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby client for memcached supporting advanced protocol features and pluggable
+  architecture.
+email:
 - git@justinbalthrop.com
 executables: []
-
-extensions: []
-
+extensions:
+- ext/extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .rbenv-gemsets
 - .rbenv-version
@@ -134,41 +123,32 @@ files:
 - test/memcache_server_test_helper.rb
 - test/memcache_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: https://github.com/ninjudd/memcache
-licenses: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+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: 1.5.2
+rubygems_version: 2.0.5
 signing_key: 
-specification_version: 3
-summary: Ruby client for memcached supporting advanced protocol features and pluggable architecture.
-test_files: 
+specification_version: 4
+summary: Ruby client for memcached supporting advanced protocol features and pluggable
+  architecture.
+test_files:
 - test/memcache_local_server_test.rb
 - test/memcache_native_server_test.rb
 - test/memcache_null_server_test.rb