memcached 0.7.2 → 0.8

data/BENCHMARKS

@@ -10,34 +10,34 @@ You can easily run your own benchmarks, as long as you have memcached itself on
 These benchmarks were run on 32-bit Intel OS X 10.4:
 
                                        user     system      total        real
-  set:plain:noblock:memcached      0.140000   0.010000   0.150000 (  0.511496)
-  set:plain:memcached              0.300000   0.330000   0.630000 (  1.885052)
-  set:plain:memcache-client       47.900000   1.320000  49.220000 ( 65.757080)
-  set:ruby:noblock:memcached       0.240000   0.010000   0.250000 (  0.721554)
-  set:ruby:memcached               0.400000   0.300000   0.700000 (  2.206571)
-  set:ruby:caffeine                6.150000   0.910000   7.060000 ( 11.954644)
-  set:ruby:memcache-client        47.450000   1.260000  48.710000 ( 62.016943)
-  get:plain:memcached              0.360000   0.310000   0.670000 (  2.232519)
-  get:plain:memcache-client       47.010000   1.000000  48.010000 ( 54.759212)
-  get:ruby:memcached               0.380000   0.320000   0.700000 (  1.681682)
-  get:ruby:caffeine                5.780000   0.920000   6.700000 (  9.658255)
-  get:ruby:memcache-client        47.820000   1.250000  49.070000 ( 67.857959)
-  missing:ruby:memcached           0.760000   0.360000   1.120000 (  2.500735)
-  missing:ruby:caffeine            5.510000   0.900000   6.410000 (  9.652409)
-  missing:ruby:memcache-client    47.100000   1.180000  48.280000 ( 63.901434)
-  mixed:ruby:noblock:memcached     0.810000   0.690000   1.500000 (  4.270386)
-  mixed:ruby:memcached             0.820000   0.660000   1.480000 (  4.272916)
-  mixed:ruby:caffeine             10.590000   1.850000  12.440000 ( 20.338369)
-  mixed:ruby:memcache-client      95.730000   2.400000  98.130000 (121.600738)
-  hash:fnv1_32:memcached           1.310000   1.330000   2.640000 (  8.634078)
-  hash:fnv1_64:memcached           1.390000   1.340000   2.730000 (  9.794876)
-  hash:md5:memcached               1.460000   1.300000   2.760000 (  9.080550)
-  hash:hsieh:memcached             1.310000   1.350000   2.660000 (  7.182591)
-  hash:ketama:memcached            1.470000   1.260000   2.730000 (  7.366949)
-  hash:fnv1a_32:memcached          1.290000   1.350000   2.640000 (  7.134969)
-  hash:default:memcached           1.360000   1.350000   2.710000 (  8.464221)
-  hash:fnv1a_64:memcached          1.350000   1.290000   2.640000 ( 10.121386)
-  hash:crc:memcached               1.370000   1.210000   2.580000 (  9.665065)
+  set:plain:noblock:memcached      0.110000   0.020000   0.130000 (  0.306181)
+  set:plain:memcached              0.260000   0.330000   0.590000 (  1.332132)
+  set:plain:memcache-client       46.830000   0.640000  47.470000 ( 49.439137)
+  set:ruby:noblock:memcached       0.190000   0.020000   0.210000 (  0.344947)
+  set:ruby:memcached               0.360000   0.340000   0.700000 (  1.502977)
+  set:ruby:caffeine                5.480000   0.890000   6.370000 (  7.224237)
+  set:ruby:memcache-client        47.460000   0.630000  48.090000 ( 50.113758)
+  get:plain:memcached              0.340000   0.340000   0.680000 (  1.346579)
+  get:plain:memcache-client       47.480000   0.600000  48.080000 ( 49.662450)
+  get:ruby:memcached               0.400000   0.350000   0.750000 (  1.464317)
+  get:ruby:caffeine                5.410000   0.900000   6.310000 (  7.142927)
+  get:ruby:memcache-client        47.600000   0.720000  48.320000 ( 51.090209)
+  missing:ruby:memcached           0.750000   0.380000   1.130000 (  1.786494)
+  missing:ruby:caffeine            5.130000   0.870000   6.000000 (  6.854605)
+  missing:ruby:memcache-client    46.870000   0.610000  47.480000 ( 49.318730)
+  mixed:ruby:noblock:memcached     0.740000   0.840000   1.580000 (  2.747368)
+  mixed:ruby:memcached             0.740000   0.680000   1.420000 (  2.825775)
+  mixed:ruby:caffeine              9.670000   1.770000  11.440000 ( 13.203683)
+  mixed:ruby:memcache-client      94.910000   1.380000  96.290000 (101.312885)
+  hash:fnv1a_64:memcached          1.170000   1.360000   2.530000 (  5.374056)
+  hash:crc:memcached               1.160000   1.330000   2.490000 (  5.422227)
+  hash:fnv1_32:memcached           1.150000   1.350000   2.500000 (  5.356032)
+  hash:fnv1_64:memcached           1.200000   1.370000   2.570000 (  5.487689)
+  hash:default:memcached           1.160000   1.360000   2.520000 (  5.506072)
+  hash:md5:memcached               1.240000   1.320000   2.560000 (  5.930740)
+  hash:hsieh:memcached             1.150000   1.370000   2.520000 (  5.505223)
+  hash:ketama:memcached            1.230000   1.340000   2.570000 (  5.759874)
+  hash:fnv1a_32:memcached          1.150000   1.360000   2.510000 (  5.562683)
 
 
 == x86-64 Linux
@@ -45,57 +45,28 @@ These benchmarks were run on 32-bit Intel OS X 10.4:
 These benchmarks were run on AMD64 RHEL4:
 
                                        user     system      total        real
-  set:plain:noblock:memcached      0.120000   0.010000   0.130000 (  3.700668)
-  set:plain:memcached              0.200000   0.190000   0.390000 (  0.787187)
-  set:plain:memcache-client       13.860000   0.210000  14.070000 ( 14.562234)
-  set:ruby:noblock:memcached       0.190000   0.010000   0.200000 (  5.347384)
-  set:ruby:memcached               0.290000   0.150000   0.440000 (  0.884206)
-  set:ruby:memcache-client        13.980000   0.200000  14.180000 ( 14.752663)
-  get:plain:memcached              0.270000   0.170000   0.440000 (  0.745219)
-  get:plain:memcache-client       14.070000   0.210000  14.280000 ( 14.794583)
-  get:ruby:memcached               0.370000   0.180000   0.550000 (  0.910926)
-  get:ruby:memcache-client        14.120000   0.220000  14.340000 ( 14.921784)
-  missing:ruby:memcached           0.550000   0.180000   0.730000 (  1.111790)
-  missing:ruby:memcache-client    13.600000   0.220000  13.820000 ( 14.427924)
-  mixed:ruby:noblock:memcached     0.560000   0.300000   0.860000 (  1.496428)
-  mixed:ruby:memcached             0.620000   0.370000   0.990000 (  1.654926)
-  mixed:ruby:memcache-client      27.580000   0.410000  27.990000 ( 28.854146)
-  hash:fnv1a_64:memcached          0.980000   0.740000   1.720000 (  3.162248)
-  hash:fnv1_32:memcached           0.990000   0.710000   1.700000 (  3.008045)
-  hash:fnv1_64:memcached           0.990000   0.710000   1.700000 (  3.018584)
-  hash:default:memcached           1.060000   0.680000   1.740000 (  3.094764)
-  hash:crc:memcached               0.980000   0.640000   1.620000 (  3.219268)
-  hash:hsieh:memcached             0.950000   0.770000   1.720000 (  3.328382)
-  hash:ketama:memcached            1.000000   0.770000   1.770000 (  3.120591)
-  hash:md5:memcached               0.990000   0.750000   1.740000 (  3.076737)
-  hash:fnv1a_32:memcached          0.950000   0.750000   1.700000 (  2.973986)
-  
-== x86-64 Linux/Xen
-
-These benchmarks were run on AMD64 Ubuntu 6.0.6 as a Xen guest:
-  
-                                       user     system      total        real
-  set:plain:noblock:memcached      0.090000   0.100000   0.190000 (  0.767657)
-  set:plain:memcached              0.120000   0.200000   0.320000 (  1.480487)
-  set:plain:memcache-client       18.620000  11.380000  30.000000 ( 32.116703)
-  set:ruby:noblock:memcached       0.220000   0.050000   0.270000 (  0.296509)
-  set:ruby:memcached               0.150000   0.210000   0.360000 (  1.345469)
-  set:ruby:memcache-client        19.310000  11.750000  31.060000 ( 32.858902)
-  get:plain:memcached              0.120000   0.130000   0.250000 (  1.291883)
-  get:plain:memcache-client       19.580000  11.930000  31.510000 ( 32.982464)
-  get:ruby:memcached               0.120000   0.160000   0.280000 (  1.404061)
-  get:ruby:memcache-client        19.520000  11.740000  31.260000 ( 33.537986)
-  missing:ruby:memcached           0.440000   0.240000   0.680000 (  1.527592)
-  missing:ruby:memcache-client    19.030000  11.760000  30.790000 ( 31.800959)
-  mixed:ruby:noblock:memcached     0.100000   0.080000   0.180000 (100.035915)
-  mixed:ruby:memcached             0.380000   0.380000   0.760000 (  2.728911)
-  mixed:ruby:memcache-client      38.890000  23.740000  62.630000 ( 66.185559)
-  hash:hsieh:memcached             0.440000   0.680000   1.120000 (  5.119760)
-  hash:crc:memcached               0.410000   0.810000   1.220000 (  5.378614)
-  hash:md5:memcached               0.430000   0.710000   1.140000 (  5.410604)
-  hash:ketama:memcached            0.770000   0.850000   1.620000 (  5.379337)
-  hash:fnv1a_32:memcached          0.300000   0.650000   0.950000 (  5.110063)
-  hash:default:memcached           0.220000   0.530000   0.750000 (  5.183058)
-  hash:fnv1a_64:memcached          0.300000   0.550000   0.850000 (  5.152530)
-  hash:fnv1_32:memcached           0.360000   0.770000   1.130000 (  5.150417)
-  hash:fnv1_64:memcached           0.510000   0.650000   1.160000 (  5.038078)
+  set:plain:noblock:memcached      0.100000   0.010000   0.110000 (  3.387985)
+  set:plain:memcached              0.160000   0.310000   0.470000 (  0.744728)
+  set:plain:memcache-client       13.710000   0.110000  13.820000 ( 14.021691)
+  set:ruby:noblock:memcached       0.170000   0.000000   0.170000 (  3.513274)
+  set:ruby:memcached               0.210000   0.380000   0.590000 (  0.812180)
+  set:ruby:memcache-client        13.600000   0.220000  13.820000 ( 14.232239)
+  get:plain:memcached              0.150000   0.310000   0.460000 (  0.747339)
+  get:plain:memcache-client       14.020000   0.290000  14.310000 ( 14.706064)
+  get:ruby:memcached               0.320000   0.250000   0.570000 (  0.828972)
+  get:ruby:memcache-client        14.050000   0.220000  14.270000 ( 14.648995)
+  missing:ruby:memcached           0.530000   0.280000   0.810000 (  1.117403)
+  missing:ruby:memcache-client    13.660000   0.200000  13.860000 ( 14.315195)
+  mixed:ruby:noblock:memcached     0.500000   0.490000   0.990000 (  1.541679)
+  mixed:ruby:memcached             0.470000   0.550000   1.020000 (  1.691884)
+  mixed:ruby:memcache-client      27.640000   0.480000  28.120000 ( 28.921745)
+  hash:crc:memcached               0.650000   1.200000   1.850000 (  3.112681)
+  hash:fnv1_32:memcached           0.660000   1.140000   1.800000 (  2.985026)
+  hash:fnv1_64:memcached           0.630000   1.280000   1.910000 (  3.027491)
+  hash:default:memcached           0.680000   1.120000   1.800000 (  2.991388)
+  hash:hsieh:memcached             0.760000   1.220000   1.980000 (  3.074890)
+  hash:fnv1a_32:memcached          0.680000   1.190000   1.870000 (  2.996147)
+  hash:md5:memcached               0.650000   1.230000   1.880000 (  3.126424)
+  hash:ketama:memcached            0.650000   1.200000   1.850000 (  3.062838)
+  hash:fnv1a_64:memcached          0.610000   1.300000   1.910000 (  3.030487)
+  

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.8. CAS support. Update to libmemcached 0.16.
+
 v0.7.2. Auto-repair unprintable characters and too-long keys; improve performance of namespacing operation.
 
 v0.7.1. Allow for explicit resetting of the struct on each request, at least until Brian fixes the synchronization problem.

data/COMPATIBILITY

@@ -4,7 +4,7 @@
 This chart shows which versions of the Ruby library are compatible with which versions of libmemcached.
 
 <b>Library version</b>:: <b>libmemcached version</b>
-0.7.1:: 0.15
+0.8:: 0.16
 0.7:: 0.15
 0.6:: 0.13
 0.5:: 0.13

data/README

@@ -22,15 +22,14 @@ The <b>memcached</b> library wraps the pure-C libmemcached client via SWIG.
 
 == Installation
 
-You need Ruby 1.8.6, and {libmemcached 0.15}[http://tangent.org/552/libmemcached.html]. Other versions are not supported. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
+You need Ruby 1.8.6, and {libmemcached 0.16}[http://tangent.org/552/libmemcached.html]. Other versions are not supported. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
 
-Download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.15.tar.gz]. Then for Linux, run:
+For Linux, download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.16.tar.gz]. Then run:
   ./configure
   make && sudo make install
   
-For OS X/MacPorts, run:
-  ./configure --prefix=/opt/local
-  make && sudo make install
+For OS X, you may be able to install it from MacPorts:
+  sudo port install libmemcached @0.16_0
   
 Now install the gem:
   sudo gem install memcached --no-rdoc --no-ri

data/TODO

@@ -1,4 +1,2 @@
 
 * Verify libmemcached version
-
-* CAS support

data/ext/rlibmemcached.i

@@ -16,22 +16,16 @@
 %apply unsigned short { uint8_t };
 %apply unsigned int { uint16_t };
 %apply unsigned long { uint32_t flags, uint32_t offset };
+/* %apply unsigned long long { uint64_t cas }; */
 
-// For behavior's weird set interface
-
+// For behavior's set interface
 %typemap(in) (void *data) {
   int value = FIX2INT($input);
-  if (value == 0 || value == 1) {
-    $1 = (void *) value;
-  } else {
-    // Only pass by reference for :distribution and :hash 
-    value = value - 2; 
-    $1 = &value;
-  }
+  // printf("%d\n", value);
+  $1 = &value;
 };
 
 // Array of strings map for multiget
-
 %typemap(in) (char **keys, size_t *key_length, unsigned int number_of_keys) {
   int i;
   Check_Type($input, T_ARRAY);
@@ -49,7 +43,6 @@
 }
 
 // Generic strings
-
 %typemap(in) (char *str, size_t len) {
  $1 = STR2CSTR($input);
  $2 = (size_t) RSTRING($input)->len;
@@ -63,23 +56,22 @@
 
 //// Output maps
 
+/* %apply unsigned long long { uint64_t cas }; */
 %apply unsigned short *OUTPUT {memcached_return *error}
 %apply unsigned int *OUTPUT {uint32_t *flags}
 %apply size_t *OUTPUT {size_t *value_length}
 %apply unsigned long long *OUTPUT {uint64_t *value}
 
 // String
-
 %typemap(in, numinputs=0) (char *key, size_t *key_length) {
-  $1 = malloc(512*sizeof(char));
-  $2 = malloc(sizeof(size_t)); // XXX Could possibly be the address of a local
+  char string[256];
+  size_t length = 0;
+  $1 = string;
+  $2 = &length;
 }; 
 %typemap(argout) (char *key, size_t *key_length) {
-  if ($1 != NULL) {
-    rb_ary_push($result, rb_str_new($1, *$2));
-    free($1);
-    free($2);
-  }
+  // Pushes an empty string when *key_length == 0
+  rb_ary_push($result, rb_str_new($1, *$2)); 
 }
 
 // Array of strings

data/ext/rlibmemcached_wrap.c

@@ -3690,7 +3690,7 @@ fail:
 SWIGINTERN VALUE
 _wrap_MemcachedStatSt_limit_maxbytes_set(int argc, VALUE *argv, VALUE self) {
   struct memcached_stat_st *arg1 = (struct memcached_stat_st *) 0 ;
-  uint32_t arg2 ;
+  uint64_t arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 ;
@@ -3705,14 +3705,14 @@ _wrap_MemcachedStatSt_limit_maxbytes_set(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct memcached_stat_st *)(argp1);
   {
-    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint64_t,  0 );
     if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "limit_maxbytes" "', argument " "2"" of type '" "uint32_t""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "limit_maxbytes" "', argument " "2"" of type '" "uint64_t""'"); 
     }  
     if (!argp2) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "limit_maxbytes" "', argument " "2"" of type '" "uint32_t""'");
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "limit_maxbytes" "', argument " "2"" of type '" "uint64_t""'");
     } else {
-      arg2 = *((uint32_t *)(argp2));
+      arg2 = *((uint64_t *)(argp2));
     }
   }
   if (arg1) (arg1)->limit_maxbytes = arg2;
@@ -3726,7 +3726,7 @@ fail:
 SWIGINTERN VALUE
 _wrap_MemcachedStatSt_limit_maxbytes_get(int argc, VALUE *argv, VALUE self) {
   struct memcached_stat_st *arg1 = (struct memcached_stat_st *) 0 ;
-  uint32_t result;
+  uint64_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   VALUE vresult = Qnil;
@@ -3740,7 +3740,7 @@ _wrap_MemcachedStatSt_limit_maxbytes_get(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct memcached_stat_st *)(argp1);
   result =  ((arg1)->limit_maxbytes);
-  vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN |  0 );
+  vresult = SWIG_NewPointerObj((uint64_t *)memcpy((uint64_t *)malloc(sizeof(uint64_t)),&result,sizeof(uint64_t)), SWIGTYPE_p_uint64_t, SWIG_POINTER_OWN |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -6879,13 +6879,8 @@ _wrap_memcached_behavior_set(int argc, VALUE *argv, VALUE self) {
   arg2 = (memcached_behavior)(val2);
   {
     int value = FIX2INT(argv[2]);
-    if (value == 0 || value == 1) {
-      arg3 = (void *) value;
-    } else {
-      // Only pass by reference for :distribution and :hash 
-      value = value - 2; 
-      arg3 = &value;
-    }
+    // printf("%d\n", value);
+    arg3 = &value;
   }
   result = (memcached_return)memcached_behavior_set(arg1,arg2,arg3);
   vresult = SWIG_From_int((int)(result));
@@ -7373,8 +7368,10 @@ _wrap_memcached_fetch(int argc, VALUE *argv, VALUE self) {
   VALUE vresult = Qnil;
   
   {
-    arg2 = malloc(512*sizeof(char));
-    arg3 = malloc(sizeof(size_t)); // XXX Could possibly be the address of a local
+    char string[256];
+    size_t length = 0;
+    arg2 = string;
+    arg3 = &length;
   }
   arg4 = &temp4;
   arg5 = &temp5;
@@ -7390,11 +7387,8 @@ _wrap_memcached_fetch(int argc, VALUE *argv, VALUE self) {
   result = (char *)memcached_fetch(arg1,arg2,arg3,arg4,arg5,arg6);
   vresult = SWIG_FromCharPtr(result);
   {
-    if (arg2 != NULL) {
-      rb_ary_push(vresult, rb_str_new(arg2, *arg3));
-      free(arg2);
-      free(arg3);
-    }
+    // Pushes an empty string when *key_length == 0
+    rb_ary_push(vresult, rb_str_new(arg2, *arg3)); 
   }
   if (SWIG_IsTmpObj(res4)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg4)));
@@ -8552,13 +8546,8 @@ _wrap_memcached_callback_set(int argc, VALUE *argv, VALUE self) {
   arg2 = (memcached_callback)(val2);
   {
     int value = FIX2INT(argv[2]);
-    if (value == 0 || value == 1) {
-      arg3 = (void *) value;
-    } else {
-      // Only pass by reference for :distribution and :hash 
-      value = value - 2; 
-      arg3 = &value;
-    }
+    // printf("%d\n", value);
+    arg3 = &value;
   }
   result = (memcached_return)memcached_callback_set(arg1,arg2,arg3);
   vresult = SWIG_From_int((int)(result));
@@ -8806,8 +8795,10 @@ _wrap_memcached_fetch_rvalue(int argc, VALUE *argv, VALUE self) {
   VALUE vresult = Qnil;
   
   {
-    arg2 = malloc(512*sizeof(char));
-    arg3 = malloc(sizeof(size_t)); // XXX Could possibly be the address of a local
+    char string[256];
+    size_t length = 0;
+    arg2 = string;
+    arg3 = &length;
   }
   arg4 = &temp4;
   arg5 = &temp5;
@@ -8822,11 +8813,8 @@ _wrap_memcached_fetch_rvalue(int argc, VALUE *argv, VALUE self) {
   result = (VALUE)memcached_fetch_rvalue(arg1,arg2,arg3,arg4,arg5);
   vresult = result;
   {
-    if (arg2 != NULL) {
-      rb_ary_push(vresult, rb_str_new(arg2, *arg3));
-      free(arg2);
-      free(arg3);
-    }
+    // Pushes an empty string when *key_length == 0
+    rb_ary_push(vresult, rb_str_new(arg2, *arg3)); 
   }
   if (SWIG_IsTmpObj(res4)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
@@ -9331,7 +9319,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_const(mRlibmemcached, "MEMCACHED_MAX_HOST_LENGTH", SWIG_From_int((int)(64)));
   rb_define_const(mRlibmemcached, "MEMCACHED_WHEEL_SIZE", SWIG_From_int((int)(1024)));
   rb_define_const(mRlibmemcached, "MEMCACHED_STRIDE", SWIG_From_int((int)(4)));
-  rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.14"));
+  rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.16"));
   rb_define_const(mRlibmemcached, "MEMCACHED_SUCCESS", SWIG_From_int((int)(MEMCACHED_SUCCESS)));
   rb_define_const(mRlibmemcached, "MEMCACHED_FAILURE", SWIG_From_int((int)(MEMCACHED_FAILURE)));
   rb_define_const(mRlibmemcached, "MEMCACHED_HOST_LOOKUP_FAILURE", SWIG_From_int((int)(MEMCACHED_HOST_LOOKUP_FAILURE)));
@@ -9364,6 +9352,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_const(mRlibmemcached, "MEMCACHED_FETCH_NOTFINISHED", SWIG_From_int((int)(MEMCACHED_FETCH_NOTFINISHED)));
   rb_define_const(mRlibmemcached, "MEMCACHED_TIMEOUT", SWIG_From_int((int)(MEMCACHED_TIMEOUT)));
   rb_define_const(mRlibmemcached, "MEMCACHED_BUFFERED", SWIG_From_int((int)(MEMCACHED_BUFFERED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BAD_KEY_PROVIDED", SWIG_From_int((int)(MEMCACHED_BAD_KEY_PROVIDED)));
   rb_define_const(mRlibmemcached, "MEMCACHED_MAXIMUM_RETURN", SWIG_From_int((int)(MEMCACHED_MAXIMUM_RETURN)));
   rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_MODULA", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_MODULA)));
   rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT)));
@@ -9379,6 +9368,8 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_DISTRIBUTION", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_DISTRIBUTION)));
   rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_BUFFER_REQUESTS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_BUFFER_REQUESTS)));
   rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_USER_DATA", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_USER_DATA)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_SORT_HOSTS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SORT_HOSTS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_VERIFY_KEY", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_VERIFY_KEY)));
   rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_USER_DATA", SWIG_From_int((int)(MEMCACHED_CALLBACK_USER_DATA)));
   rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_CLEANUP_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_CLEANUP_FUNCTION)));
   rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_CLONE_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_CLONE_FUNCTION)));

data/lib/memcached.rb

@@ -1,11 +1,4 @@
 
-require 'rlibmemcached'
-require 'memcached/integer'
-require 'memcached/exceptions'
-require 'memcached/behaviors'
-require 'memcached/memcached'
-require 'memcached/rails'
-
 =begin rdoc
 The generated SWIG module for accessing libmemcached's C API.
 
@@ -21,4 +14,16 @@ A number of SWIG typemaps and C helper methods are also defined in <tt>ext/libme
 
 =end
 module Rlibmemcached
-end
+end
+
+require 'rlibmemcached'
+
+class Memcached
+  Lib = Rlibmemcached
+end  
+
+require 'memcached/integer'
+require 'memcached/exceptions'
+require 'memcached/behaviors'
+require 'memcached/memcached'
+require 'memcached/rails'

data/lib/memcached/behaviors.rb

@@ -4,8 +4,8 @@ class Memcached
 #:stopdoc:
 
   def self.load_constants(prefix, hash = {}, offset = 0)
-    Rlibmemcached.constants.grep(/^#{prefix}/).each do |const_name|
-      hash[const_name[prefix.length..-1].downcase.to_sym] = Rlibmemcached.const_get(const_name) + offset
+    Lib.constants.grep(/^#{prefix}/).each do |const_name|
+      hash[const_name[prefix.length..-1].downcase.to_sym] = Lib.const_get(const_name) + offset
     end
     hash
   end
@@ -42,8 +42,8 @@ class Memcached
     # STDERR.puts "Setting #{behavior}:#{b_id} => #{value}:#{v_id}"
     
     unless value == false
-      # XXX Setting false still turns on the behavior; maybe a Rlibmemcached bug
-      Rlibmemcached.memcached_behavior_set(@struct, b_id, v_id)
+      # XXX Setting false still turns on the behavior; maybe a Lib bug
+      Lib.memcached_behavior_set(@struct, b_id, v_id)
     end
     
   end  

data/lib/memcached/exceptions.rb

@@ -9,6 +9,7 @@ Subclasses correspond one-to-one with server response strings or libmemcached er
 
 == Subclasses
 
+* Memcached::ABadKeyWasProvidedOrCharactersOutOfRange
 * Memcached::AKeyLengthOfZeroWasProvided
 * Memcached::ATimeoutOccurred
 * Memcached::ActionNotSupported
@@ -56,7 +57,7 @@ Subclasses correspond one-to-one with server response strings or libmemcached er
   class << self
     private
     def camelize(string)
-      string.downcase.split(' ').map {|s| s.capitalize}.join
+      string.downcase.gsub('/', ' or ').split(' ').map {|s| s.capitalize}.join
     end   
   end
   

data/lib/memcached/memcached.rb

@@ -13,14 +13,15 @@ class Memcached
     :buffer_requests => false,
     :support_cas => false,
     :tcp_nodelay => false,
-    :namespace => nil
-  }
+    :namespace => nil    
+  } 
+    
+  # :sort_hosts => false # XXX No effect due to libmemcached 0.16 bug
+  # :verify_key => false # XXX We do this ourselves already in Rlibmemcached.ns()
   
 #:stopdoc:
   IGNORED = 0
   
-  Lib = Rlibmemcached
-  
   NOTFOUND_INSTANCE = NotFound.new
 #:startdoc:
   
@@ -48,11 +49,12 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
 =end
 
   def initialize(servers, opts = {})
-    @struct = Lib::MemcachedSt.new
+    @struct = Lib::MemcachedSt.new    
     Lib.memcached_create(@struct)
 
     # Servers
-    Array(servers).each_with_index do |server, index|
+    # XXX We have to sort them ahead of time due to a libmemcached 0.16 bug
+    Array(servers).sort.each_with_index do |server, index|
       unless server.is_a? String and server =~ /^(\d{1,3}\.){3}\d{1,3}:\d{1,5}$/
         raise ArgumentError, "Servers must be in the format ip:port (e.g., '127.0.0.1:11211')" 
       end
@@ -104,6 +106,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def destroy(disable_methods = true)
     Lib.memcached_free(@struct)
     @struct = nil
+    
     if disable_methods
       class << self
         Memcached.instance_methods.each do |method_name|
@@ -215,17 +218,22 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     )
   end
   
-  # Not yet implemented.
-  #
   # Reads a key's value from the server and yields it to a block. Replaces the key's value with the result of the block as long as the key hasn't been updated in the meantime, otherwise raises <b>Memcached::NotStored</b>. Accepts a String <tt>key</tt> and a block.
   #
   # Also accepts an optional <tt>timeout</tt> value.
   #
-  # CAS stands for "compare and swap", and avoids the need for manual key mutexing. CAS support must be enabled in Memcached.new or a <b>Memcached::ClientError</b> will be raised.
-  def cas(*args)
-    # Requires memcached HEAD
-    raise NotImplemented
+  # CAS stands for "compare and swap", and avoids the need for manual key mutexing. CAS support must be enabled in Memcached.new or a <b>Memcached::ClientError</b> will be raised. Note that CAS may be buggy in memcached itself.
+  #
+  def cas(key, timeout = 0, marshal = true)
     raise ClientError, "CAS not enabled for this Memcached instance" unless options[:support_cas]
+      
+    value = get(key)
+    value = yield value
+    value = marshal ? Marshal.dump(value) : value.to_s
+    
+    check_return_code(
+      Lib.memcached_cas(@struct, Lib.ns(@namespace, key), value, timeout, FLAGS, @struct.result.cas)
+    )
   end
 
 ### Deleters
@@ -316,7 +324,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
     
   # Checks the return code from Rlibmemcached against the exception list. Raises the corresponding exception if the return code is not Memcached::Success or Memcached::ActionQueued. Accepts an integer return code.
   def check_return_code(ret) #:doc:
-    # 0.14 returns 0 for an ActionQueued result but 0.15 does not.
+    # 0.16 --enable-debug returns 0 for an ActionQueued result but --disable-debug does not
     return if ret == 0 or ret == 31
     raise EXCEPTIONS[ret], ""
   end  

data/memcached.gemspec

@@ -1,16 +1,16 @@
 
-# Gem::Specification for Memcached-0.7.2
+# Gem::Specification for Memcached-0.8
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.7.2"
+  s.version = "0.8"
 
   s.specification_version = 2 if s.respond_to? :specification_version=
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
-  s.date = %q{2008-02-10}
+  s.date = %q{2008-02-18}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]

data/test/unit/memcached_test.rb

@@ -74,6 +74,32 @@ class MemcachedTest < Test::Unit::TestCase
       cache.set key, @value
     end
   end
+  
+  def test_initialize_sort_hosts
+    # Original
+    cache = Memcached.new(@servers.sort)
+    assert_equal @servers.sort, 
+      cache.servers
+    cache.destroy
+    
+    # Reversed 
+    # XXX Fails due to libmemcached 0.16 bug
+    # cache = Memcached.new(@servers.sort.reverse)
+    # assert_equal @servers.sort.reverse, 
+    #  cache.servers
+    # cache.destroy
+      
+    # Reversed with sort_hosts
+    cache = Memcached.new(@servers.sort.reverse,
+      :sort_hosts => true)
+    assert_equal @servers.sort, 
+      cache.servers
+    cache.destroy
+  end
+  
+  # def test_initialize_verify_key
+  #  # XXX Not necessary
+  # end
 
   def test_initialize_single_server
     cache = Memcached.new '127.0.0.1:43042'
@@ -144,6 +170,15 @@ class MemcachedTest < Test::Unit::TestCase
       @cache.get(["#{key}_1", "#{key}_2",  "#{key}_3",  "#{key}_4"])
      )
   end
+  
+  def test_get_multi_completely_missing
+    @cache.delete "#{key}_1" rescue nil
+    @cache.delete "#{key}_2" rescue nil    
+    assert_equal(
+      {},
+      @cache.get(["#{key}_1", "#{key}_2"])
+     )
+  end  
 
   def test_set_and_get_unmarshalled
     @cache.set key, @value
@@ -336,11 +371,37 @@ class MemcachedTest < Test::Unit::TestCase
   end
 
   def test_cas
-    assert_raise Memcached::NotImplemented do
-      @cache.cas(key) do
-        @value
+    cache = Memcached.new(
+      @servers, 
+      :namespace => @namespace, 
+      :support_cas => true
+    )        
+    value2 = OpenStruct.new(:d => 3, :e => 4, :f => GenericClass)
+
+    # Existing set
+    cache.set key, @value
+    cache.cas(key) do |current|
+      assert_equal @value, current
+      value2
+    end
+    assert_equal value2, cache.get(key)
+    
+    # Missing set
+    cache.delete key
+    assert_raises(Memcached::NotFound) do
+      cache.cas(key) {}
+    end
+    
+    # Conflicting set
+    cache.set key, @value
+    assert_raises(Memcached::ConnectionDataExists) do
+      cache.cas(key) do |current|
+        cache.set key, value2
+        current
       end
     end
+    
+    cache.destroy    
   end
   
   # Namespace and key validation

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcached
 version: !ruby/object:Gem::Version 
-  version: 0.7.2
+  version: "0.8"
 platform: ruby
 authors: 
 - Evan Weaver
@@ -30,7 +30,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2008-02-10 00:00:00 -05:00
+date: 2008-02-18 00:00:00 -05:00
 default_executable: 
 dependencies: []