memcached 1.2.4.pre → 1.2.5

data/CHANGELOG

@@ -1,4 +1,4 @@
-v1.2.4.pre. Compile properly on JRuby.
+v1.2.5. Compile properly on JRuby (but doesn't run yet). Do zero-copy Ruby string allocations to improve performance.
 
 v1.2.3. Don't keep the server strings around forever.
 

data/Rakefile

@@ -1,3 +1,4 @@
+gem 'echoe', '>= 4.5.6'
 require 'echoe'
 
 Echoe.new("memcached") do |p|
@@ -20,6 +21,19 @@ task :exceptions do
   end
 end
 
+task :test_all do
+  if !system("rvm use ree-1.8.7-2010.02 && rake clean && rake")
+    puts "REE test failed"
+    exit(1)
+  end
+  if !system("rvm use ruby-1.9.2 && rake clean && rake")
+    puts "1.9 test failed"
+    exit(1)
+  end
+end
+
+task :prerelease => [:test_all]
+
 task :benchmark do
  exec("ruby #{File.dirname(__FILE__)}/test/profile/benchmark.rb")
 end

data/ext/rlibmemcached.i

@@ -39,7 +39,7 @@
 
 // Array of strings map for multiget
 %typemap(in) (const char **keys, size_t *key_length, size_t number_of_keys) {
-  int i;
+  unsigned int i;
   Check_Type($input, T_ARRAY);
   $3 = (unsigned int) RARRAY_LEN($input);
   $2 = (size_t *) malloc(($3+1)*sizeof(size_t));
@@ -102,12 +102,6 @@
  $result = UINT2NUM($1);
 };
 
-// Void type strings without lengths for prefix_key callback
-// Currently not used by the gem
-%typemap(out) (void *) {
- $result = rb_str_new2($1);
-};
-
 // String for memcached_fetch
 %typemap(in, numinputs=0) (char *key, size_t *key_length) {
   char string[256];
@@ -122,6 +116,7 @@
 }
 
 // Array of strings
+// Only used by memcached_stat_get_keys() and not performance-critical
 %typemap(out) (char **) {
   int i;
   VALUE ary = rb_ary_new();
@@ -147,44 +142,56 @@
 
 //// Custom C functions
 
+VALUE rb_str_new_by_ref(char *ptr, long len);
+%{
+VALUE rb_str_new_by_ref(char *ptr, long len)
+{
+    NEWOBJ(str, struct RString);
+    OBJSETUP(str, rb_cString, T_STRING);
+#ifdef RSTRING_NOEMBED
+    /* Ruby 1.9 */
+    str->as.heap.ptr = ptr;
+    str->as.heap.len = len;
+    str->as.heap.aux.capa = len + 1;
+    // Set STR_NOEMBED
+    FL_SET(str, FL_USER1);
+#else
+    /* Ruby 1.8 */
+    str->ptr = ptr;
+    str->len = len;
+    str->aux.capa = 0;
+#endif
+    return (VALUE)str;
+}
+%}
+
 //// Manual wrappers
 
-// Single get. SWIG likes to use SWIG_FromCharPtr instead of SWIG_FromCharPtrAndSize because
-// of the retval/argout split, so it truncates return values with \0 in them. There is probably a better
-// way to do this.
+// Single get
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;
   size_t value_length = 0;
   char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
-  ret = rb_str_new(value, value_length);
-  free(value);
-  return ret;
+  return rb_str_new_by_ref(value, value_length);
 };
 %}
 
 VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
-  VALUE ret;
   size_t value_length = 0;
   char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
-  ret = rb_str_new(value, value_length);
-  free(value);
-  return ret;
+  return rb_str_new_by_ref(value, value_length);
 };
 %}
 
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;
   size_t value_length = 0;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
-  ret = rb_str_new(value, value_length);
-  free(value);
-  return ret;
+  return rb_str_new_by_ref(value, value_length);
 };
 %}
 
@@ -193,12 +200,11 @@ VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, u
 %{
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
   size_t value_length = 0;
-  VALUE result = rb_ary_new();
+  VALUE ary = rb_ary_new();
   char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
-  VALUE ret = rb_str_new(value, value_length);
-  rb_ary_push(result, ret);
-  free(value);
-  return result;
+  VALUE str = rb_str_new_by_ref(value, value_length);
+  rb_ary_push(ary, str);
+  return ary;
 };
 %}
 

data/ext/rlibmemcached_wrap.c

@@ -1821,8 +1821,9 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_size_t swig_types[29]
 #define SWIGTYPE_p_uint32_t swig_types[30]
 #define SWIGTYPE_p_uint64_t swig_types[31]
-static swig_type_info *swig_types[33];
-static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0};
+#define SWIGTYPE_p_void swig_types[32]
+static swig_type_info *swig_types[34];
+static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -2252,44 +2253,55 @@ SWIG_From_unsigned_SS_int  (unsigned int value)
 }
 
 
+VALUE rb_str_new_by_ref(char *ptr, long len)
+{
+    NEWOBJ(str, struct RString);
+    OBJSETUP(str, rb_cString, T_STRING);
+#ifdef RSTRING_NOEMBED
+    /* Ruby 1.9 */
+    str->as.heap.ptr = ptr;
+    str->as.heap.len = len;
+    str->as.heap.aux.capa = len + 1;
+    // Set STR_NOEMBED
+    FL_SET(str, FL_USER1);
+#else
+    /* Ruby 1.8 */
+    str->ptr = ptr;
+    str->len = len;
+    str->aux.capa = 0;
+#endif
+    return (VALUE)str;
+}
+
+
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;
   size_t value_length = 0;
   char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
-  ret = rb_str_new(value, value_length);
-  free(value);
-  return ret;
+  return rb_str_new_by_ref(value, value_length);
 };
 
 
 VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
-  VALUE ret;
   size_t value_length = 0;
   char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
-  ret = rb_str_new(value, value_length);
-  free(value);
-  return ret;
+  return rb_str_new_by_ref(value, value_length);
 };
 
 
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;
   size_t value_length = 0;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
-  ret = rb_str_new(value, value_length);
-  free(value);
-  return ret;
+  return rb_str_new_by_ref(value, value_length);
 };
 
 
 VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
   size_t value_length = 0;
-  VALUE result = rb_ary_new();
+  VALUE ary = rb_ary_new();
   char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
-  VALUE ret = rb_str_new(value, value_length);
-  rb_ary_push(result, ret);
-  free(value);
-  return result;
+  VALUE str = rb_str_new_by_ref(value, value_length);
+  rb_ary_push(ary, str);
+  return ary;
 };
 
 
@@ -5647,9 +5659,7 @@ _wrap_MemcachedSt_user_data_get(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct memcached_st *)(argp1);
   result = (void *) ((arg1)->user_data);
-  {
-    vresult = rb_str_new2(result);
-  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -8328,9 +8338,7 @@ _wrap_memcached_callback_get(int argc, VALUE *argv, VALUE self) {
   } 
   arg2 = (memcached_callback)(val2);
   result = (void *)memcached_callback_get(arg1,arg2,arg3);
-  {
-    vresult = rb_str_new2(result);
-  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
   if (SWIG_IsTmpObj(res3)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
   } else {
@@ -8545,9 +8553,7 @@ _wrap_memcached_get_user_data(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   result = (void *)memcached_get_user_data(arg1);
-  {
-    vresult = rb_str_new2(result);
-  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -8579,9 +8585,7 @@ _wrap_memcached_set_user_data(int argc, VALUE *argv, VALUE self) {
     }
   }
   result = (void *)memcached_set_user_data(arg1,arg2);
-  {
-    vresult = rb_str_new2(result);
-  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -8760,7 +8764,7 @@ _wrap_memcached_mget(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    int i;
+    unsigned int i;
     Check_Type(argv[1], T_ARRAY);
     arg4 = (unsigned int) RARRAY_LEN(argv[1]);
     arg3 = (size_t *) malloc((arg4+1)*sizeof(size_t));
@@ -8810,7 +8814,7 @@ _wrap_memcached_mget_len(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    int i;
+    unsigned int i;
     Check_Type(argv[1], T_ARRAY);
     arg4 = (unsigned int) RARRAY_LEN(argv[1]);
     arg3 = (size_t *) malloc((arg4+1)*sizeof(size_t));
@@ -8952,7 +8956,7 @@ _wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
   } 
   arg3 = (size_t)(val3);
   {
-    int i;
+    unsigned int i;
     Check_Type(argv[3], T_ARRAY);
     arg6 = (unsigned int) RARRAY_LEN(argv[3]);
     arg5 = (size_t *) malloc((arg6+1)*sizeof(size_t));
@@ -12410,6 +12414,41 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_rb_str_new_by_ref(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  long arg2 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  long val2 ;
+  int ecode2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char *","rb_str_new_by_ref", 1, argv[0] ));
+  }
+  arg1 = (char *)(buf1);
+  ecode2 = SWIG_AsVal_long(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","rb_str_new_by_ref", 2, argv[1] ));
+  } 
+  arg2 = (long)(val2);
+  result = (VALUE)rb_str_new_by_ref(arg1,arg2);
+  vresult = result;
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  return vresult;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_get_rvalue(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -12760,6 +12799,7 @@ static swig_type_info _swigt__p_sasl_callback_t = {"_p_sasl_callback_t", "sasl_c
 static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_addrinfo,
@@ -12794,6 +12834,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_size_t,
   &_swigt__p_uint32_t,
   &_swigt__p_uint64_t,
+  &_swigt__p_void,
 };
 
 static swig_cast_info _swigc__p_addrinfo[] = {  {&_swigt__p_addrinfo, 0, 0, 0},{0, 0, 0, 0}};
@@ -12828,6 +12869,7 @@ static swig_cast_info _swigc__p_sasl_callback_t[] = {  {&_swigt__p_sasl_callback
 static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_uint32_t[] = {  {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_uint64_t[] = {  {&_swigt__p_uint64_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_addrinfo,
@@ -12862,6 +12904,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_size_t,
   _swigc__p_uint32_t,
   _swigc__p_uint64_t,
+  _swigc__p_void,
 };
 
 
@@ -13578,6 +13621,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_module_function(mRlibmemcached, "memcached_destroy_sasl_auth_data", _wrap_memcached_destroy_sasl_auth_data, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_sasl_callbacks", _wrap_memcached_get_sasl_callbacks, -1);
   rb_define_module_function(mRlibmemcached, "memcached_sasl_authenticate_connection", _wrap_memcached_sasl_authenticate_connection, -1);
+  rb_define_module_function(mRlibmemcached, "rb_str_new_by_ref", _wrap_rb_str_new_by_ref, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_len_rvalue", _wrap_memcached_get_len_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_from_last_rvalue", _wrap_memcached_get_from_last_rvalue, -1);

data/memcached.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "1.2.4.pre"
+  s.version = "1.2.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
   s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
-  s.date = %q{2011-03-28}
+  s.date = %q{2011-03-30}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]

data/test/profile/benchmark.rb

@@ -3,7 +3,7 @@ HERE = File.dirname(__FILE__)
 $LOAD_PATH << "#{HERE}/../../lib/"
 UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached')
 
-require 'memcached'
+require 'memcached' if !defined?(JRUBY_VERSION)
 require 'benchmark'
 require 'rubygems'
 require 'ruby-debug' if ENV['DEBUG']
@@ -14,16 +14,13 @@ puts `ruby -v`
 puts `env | egrep '^RUBY'`
 puts "Ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
 
-[ ["memcached", "memcached"],
-  ["remix-stash", "remix/stash"],
-  # ["astro-remcached", "remcached"], # Clobbers the "Memcached" constant
-  ["memcache-client", "memcache"],
-  ["kgio", "kgio"],
-  ["dalli","dalli"]
-  ].each do |gem_name, requirement|
-  require requirement
-  gem gem_name
-  puts "Loaded #{gem_name} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
+[["memcached"], ["remix-stash", "remix/stash"], ["memcache-client", "memcache"], ["kgio"], ["dalli"]].each do |gem_name, requirement|
+  begin
+    require requirement || gem_name
+    gem gem_name
+    puts "Loaded #{gem_name} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
+  rescue LoadError
+  end
 end
 
 class Remix::Stash
@@ -98,25 +95,30 @@ class Bench
 
   def reset_clients
     @clients = {
-       "libm:ascii" => Memcached::Rails.new(
-         ['127.0.0.1:43042', '127.0.0.1:43043'],
-         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
-       "libm:ascii:pipeline" => Memcached::Rails.new(
-         ['127.0.0.1:43042', '127.0.0.1:43043'],
-         :no_block => true, :buffer_requests => true, :noreply => true, :namespace => "namespace"),
-       "libm:ascii:udp" => Memcached::Rails.new(
-         ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"],
-         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
-       "libm:bin" => Memcached::Rails.new(
-         ['127.0.0.1:43042', '127.0.0.1:43043'],
-         :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true),
-       "libm:bin:buffer" => Memcached::Rails.new(
-         ['127.0.0.1:43042', '127.0.0.1:43043'],
-         :no_block => true, :buffer_requests => true, :namespace => "namespace", :binary_protocol => true),
-       "mclient:ascii" => MemCache.new(['127.0.0.1:43042', '127.0.0.1:43043']),
-       "stash:bin" => Remix::Stash.new(:root),
-       "dalli:bin" => Dalli::ClientCompat.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)
-       }
+      "mclient:ascii" => MemCache.new(['127.0.0.1:43042', '127.0.0.1:43043']),
+      "stash:bin" => Remix::Stash.new(:root),
+      "dalli:bin" => Dalli::ClientCompat.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)}
+
+    if defined?(JRUBY_VERSION)
+      @clients.merge!({}) # jruby-memcache-client, #spymemcached
+    else
+      @clients.merge!({
+        "libm:ascii" => Memcached::Rails.new(
+          ['127.0.0.1:43042', '127.0.0.1:43043'],
+          :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+        "libm:ascii:pipeline" => Memcached::Rails.new(
+          ['127.0.0.1:43042', '127.0.0.1:43043'],
+          :no_block => true, :buffer_requests => true, :noreply => true, :namespace => "namespace"),
+        "libm:ascii:udp" => Memcached::Rails.new(
+          ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"],
+          :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+        "libm:bin" => Memcached::Rails.new(
+          ['127.0.0.1:43042', '127.0.0.1:43043'],
+          :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true),
+        "libm:bin:buffer" => Memcached::Rails.new(
+          ['127.0.0.1:43042', '127.0.0.1:43043'],
+          :no_block => true, :buffer_requests => true, :namespace => "namespace", :binary_protocol => true)})
+    end
   end
 
   def benchmark_clients(test_name, populate_keys = true)
@@ -138,11 +140,13 @@ class Bench
           client.delete @k3
         end
         yield client
+        GC.disable
         @benchmark.report("#{test_name}: #{client_name}") { @loops.times { yield client } }
       rescue Exception => e
         puts "#{test_name}: #{client_name} => #{e.inspect}" if ENV["DEBUG"]
         reset_clients
       end
+      GC.enable
     end
     puts
   end
@@ -221,13 +225,15 @@ class Bench
       c.get @k3, true
     end
 
-    benchmark_hashes(Memcached::HASH_VALUES, "hash") do |i|
-      Rlibmemcached.memcached_generate_hash_rvalue(@k1, i)
-      Rlibmemcached.memcached_generate_hash_rvalue(@k2, i)
-      Rlibmemcached.memcached_generate_hash_rvalue(@k3, i)
-      Rlibmemcached.memcached_generate_hash_rvalue(@k4, i)
-      Rlibmemcached.memcached_generate_hash_rvalue(@k5, i)
-      Rlibmemcached.memcached_generate_hash_rvalue(@k6, i)
+    if defined?(Memcached)
+      benchmark_hashes(Memcached::HASH_VALUES, "hash") do |i|
+        Rlibmemcached.memcached_generate_hash_rvalue(@k1, i)
+        Rlibmemcached.memcached_generate_hash_rvalue(@k2, i)
+        Rlibmemcached.memcached_generate_hash_rvalue(@k3, i)
+        Rlibmemcached.memcached_generate_hash_rvalue(@k4, i)
+        Rlibmemcached.memcached_generate_hash_rvalue(@k5, i)
+        Rlibmemcached.memcached_generate_hash_rvalue(@k6, i)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: memcached
 version: !ruby/object:Gem::Version 
-  hash: 961915988
-  prerelease: 6
+  hash: 21
+  prerelease: 
   segments: 
   - 1
   - 2
-  - 4
-  - pre
-  version: 1.2.4.pre
+  - 5
+  version: 1.2.5
 platform: ruby
 authors: 
 - Evan Weaver
@@ -37,7 +36,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2011-03-28 00:00:00 -07:00
+date: 2011-03-30 00:00:00 -07:00
 default_executable: 
 dependencies: []