memcached 0.7.1 → 0.7.2

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+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.
 
 v0.7. Rails compatibility wrapper; real multiget; rescue UnknownReadFailures in order to reset the struct..

data/COMPATIBILITY

@@ -4,6 +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.7:: 0.15
 0.6:: 0.13
 0.5:: 0.13

data/Manifest

@@ -14,6 +14,7 @@ LICENSE
 Manifest
 README
 test/profile/benchmark.rb
+test/profile/key.rb
 test/profile/profile.rb
 test/profile/valgrind.rb
 test/setup.rb

data/README

@@ -22,7 +22,7 @@ The <b>memcached</b> library wraps the pure-C libmemcached client via SWIG.
 
 == Installation
 
-You need {libmemcached 0.15}[http://tangent.org/552/libmemcached.html]. Other versions of libmemcached 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.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.
 
 Download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.15.tar.gz]. Then for Linux, run:
   ./configure
@@ -35,6 +35,9 @@ For OS X/MacPorts, run:
 Now install the gem:
   sudo gem install memcached --no-rdoc --no-ri
   
+Note that on OS X 10.5 you may need to set the architecture explicitly: 
+  sudo env ARCHFLAGS="-arch i386" gem install memcached --no-rdoc --no-ri
+  
 == Usage
 
 Start a local memcached server:
@@ -62,7 +65,9 @@ You can get multiple values at once:
 
   value = 'hello'
   $cache.set 'test', value
-  $cache.get ['test', 'test2'] #=> ["hello", Memcached::NotFound]
+  $cache.set 'test2', value
+  $cache.get ['test', 'test2', 'missing'] 
+    #=> {"test" => "hello", "test2" => "hello"}
   
 You can set a counter and increment it:
 

data/ext/rlibmemcached.i

@@ -12,11 +12,13 @@
 %include "typemaps.i"
 
 //// Input maps
+
 %apply unsigned short { uint8_t };
 %apply unsigned int { uint16_t };
 %apply unsigned long { uint32_t flags, uint32_t offset };
 
 // For behavior's weird set interface
+
 %typemap(in) (void *data) {
   int value = FIX2INT($input);
   if (value == 0 || value == 1) {
@@ -29,6 +31,7 @@
 };
 
 // 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);
@@ -46,23 +49,27 @@
 }
 
 // Generic strings
+
 %typemap(in) (char *str, size_t len) {
  $1 = STR2CSTR($input);
  $2 = (size_t) RSTRING($input)->len;
 };
 
 %apply (char *str, size_t len) {
+  (char *namespace, size_t namespace_length), 
   (char *key, size_t key_length), 
   (char *value, size_t value_length)
 };
 
 //// Output maps
+
 %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
@@ -76,6 +83,7 @@
 }
 
 // Array of strings
+
 %typemap(out) (char **) {
   int i;  
   VALUE ary = rb_ary_new();
@@ -90,7 +98,33 @@
 
 %include "/opt/local/include/libmemcached/memcached.h"
 
-// Manual wrappers
+//// Custom C functions
+
+// Namespace and validate key. We could avoid several more dispatches and allocations if we called this from the libmemcached wrappers directly.
+
+VALUE ns(char *namespace, size_t namespace_length, char *key, size_t key_length);
+%{
+VALUE ns(char *namespace, size_t namespace_length, char *key, size_t key_length) {
+  char namespaced_key[250];
+  size_t namespaced_key_length = namespace_length + key_length;
+  
+  if (namespaced_key_length > 250)
+    namespaced_key_length = 250;
+  
+  strncpy(namespaced_key, namespace, namespace_length);
+  strncpy(namespaced_key + namespace_length, key, namespaced_key_length - namespace_length);
+  
+  int i;
+  for (i = 0; i < namespaced_key_length; i++)
+    if ((namespaced_key[i] < 33) || (namespaced_key[i] > 126))
+      // Outside printable range
+      namespaced_key[i] = '_';
+   
+  return rb_str_new(namespaced_key, namespaced_key_length);  
+};
+%}
+
+//// 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. 

data/ext/rlibmemcached_wrap.c

@@ -1869,6 +1869,26 @@ SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
 }
 
 
+VALUE ns(char *namespace, size_t namespace_length, char *key, size_t key_length) {
+  char namespaced_key[250];
+  size_t namespaced_key_length = namespace_length + key_length;
+  
+  if (namespaced_key_length > 250)
+    namespaced_key_length = 250;
+  
+  strncpy(namespaced_key, namespace, namespace_length);
+  strncpy(namespaced_key + namespace_length, key, namespaced_key_length - namespace_length);
+  
+  int i;
+  for (i = 0; i < namespaced_key_length; i++)
+    if ((namespaced_key[i] < 33) || (namespaced_key[i] > 126))
+      // Outside printable range
+      namespaced_key[i] = '_';
+   
+  return rb_str_new(namespaced_key, namespaced_key_length);  
+};
+
+
 VALUE memcached_get_rvalue(memcached_st *ptr, char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
   VALUE ret;  
   size_t value_length;
@@ -8691,6 +8711,34 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_ns(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  size_t arg2 ;
+  char *arg3 = (char *) 0 ;
+  size_t arg4 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    arg1 = STR2CSTR(argv[0]);
+    arg2 = (size_t) RSTRING(argv[0])->len;
+  }
+  {
+    arg3 = STR2CSTR(argv[1]);
+    arg4 = (size_t) RSTRING(argv[1])->len;
+  }
+  result = (VALUE)ns(arg1,arg2,arg3,arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_get_rvalue(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -9595,6 +9643,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_module_function(mRlibmemcached, "memcached_result_create", _wrap_memcached_result_create, -1);
   rb_define_module_function(mRlibmemcached, "memcached_result_value", _wrap_memcached_result_value, -1);
   rb_define_module_function(mRlibmemcached, "memcached_result_length", _wrap_memcached_result_length, -1);
+  rb_define_module_function(mRlibmemcached, "ns", _wrap_ns, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_fetch_rvalue", _wrap_memcached_fetch_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_stat_get_rvalue", _wrap_memcached_stat_get_rvalue, -1);

data/lib/memcached/memcached.rb

@@ -19,6 +19,8 @@ class Memcached
 #:stopdoc:
   IGNORED = 0
   
+  Lib = Rlibmemcached
+  
   NOTFOUND_INSTANCE = NotFound.new
 #:startdoc:
   
@@ -46,8 +48,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
 =end
 
   def initialize(servers, opts = {})
-    @struct = Rlibmemcached::MemcachedSt.new
-    Rlibmemcached.memcached_create(@struct)
+    @struct = Lib::MemcachedSt.new
+    Lib.memcached_create(@struct)
 
     # Servers
     Array(servers).each_with_index do |server, index|
@@ -55,7 +57,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
         raise ArgumentError, "Servers must be in the format ip:port (e.g., '127.0.0.1:11211')" 
       end
       host, port = server.split(":")
-      Rlibmemcached.memcached_server_add(@struct, host, port.to_i)
+      Lib.memcached_server_add(@struct, host, port.to_i)
     end  
     
     # Behaviors
@@ -90,7 +92,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   #
   def clone
     memcached = super
-    memcached.instance_variable_set('@struct', Rlibmemcached.memcached_clone(nil, @struct))
+    memcached.instance_variable_set('@struct', Lib.memcached_clone(nil, @struct))
     memcached
   end
   
@@ -100,7 +102,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   # runs much faster, but your instance will segfault if you try to call any other methods on it
   # after destroy. Defaults to <tt>true</tt>, which safely overwrites all instance methods.
   def destroy(disable_methods = true)
-    Rlibmemcached.memcached_free(@struct)
+    Lib.memcached_free(@struct)
     @struct = nil
     if disable_methods
       class << self
@@ -115,8 +117,8 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   
   # Reset the state of the libmemcached struct. Fixes out-of-sync errors with the Memcached pool.
   def reset
-    new_struct = Rlibmemcached.memcached_clone(nil, @struct)
-    Rlibmemcached.memcached_free(@struct)
+    new_struct = Lib.memcached_clone(nil, @struct)
+    Lib.memcached_free(@struct)
     @struct = new_struct
   end  
   
@@ -132,7 +134,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def server_structs
     array = []
     @struct.hosts.count.times do |i|
-      array << Rlibmemcached.memcached_select_server_at(@struct, i)
+      array << Lib.memcached_select_server_at(@struct, i)
     end
     array
   end    
@@ -152,7 +154,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def set(key, value, timeout=0, marshal=true)
     value = marshal ? Marshal.dump(value) : value.to_s
     check_return_code(
-      Rlibmemcached.memcached_set(@struct, ns(key), value, timeout, FLAGS)
+      Lib.memcached_set(@struct, Lib.ns(@namespace, key), value, timeout, FLAGS)
     )
   end
 
@@ -160,7 +162,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def add(key, value, timeout=0, marshal=true)
     value = marshal ? Marshal.dump(value) : value.to_s
     check_return_code(
-      Rlibmemcached.memcached_add(@struct, ns(key), value, timeout, FLAGS)
+      Lib.memcached_add(@struct, Lib.ns(@namespace, key), value, timeout, FLAGS)
     )
   end
 
@@ -170,14 +172,14 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   #
   # Note that the key must be initialized to an unmarshalled integer first, via <tt>set</tt>, <tt>add</tt>, or <tt>replace</tt> with <tt>marshal</tt> set to <tt>false</tt>.
   def increment(key, offset=1)
-    ret, value = Rlibmemcached.memcached_increment(@struct, ns(key), offset)
+    ret, value = Lib.memcached_increment(@struct, Lib.ns(@namespace, key), offset)
     check_return_code(ret)
     value
   end
 
   # Decrement a key's value. The parameters and exception behavior are the same as <tt>increment</tt>.
   def decrement(key, offset=1)
-    ret, value = Rlibmemcached.memcached_decrement(@struct, ns(key), offset)
+    ret, value = Lib.memcached_decrement(@struct, Lib.ns(@namespace, key), offset)
     check_return_code(ret)
     value
   end
@@ -191,7 +193,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def replace(key, value, timeout=0, marshal=true)
     value = marshal ? Marshal.dump(value) : value.to_s
     check_return_code(
-      Rlibmemcached.memcached_replace(@struct, ns(key), value, timeout, FLAGS)
+      Lib.memcached_replace(@struct, Lib.ns(@namespace, key), value, timeout, FLAGS)
     )
   end
 
@@ -201,7 +203,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def append(key, value)
     # Requires memcached 1.2.4
     check_return_code(
-      Rlibmemcached.memcached_append(@struct, ns(key), value.to_s, IGNORED, FLAGS)
+      Lib.memcached_append(@struct, Lib.ns(@namespace, key), value.to_s, IGNORED, FLAGS)
     )
   end
   
@@ -209,7 +211,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def prepend(key, value)
     # Requires memcached 1.2.4
     check_return_code(
-      Rlibmemcached.memcached_prepend(@struct, ns(key), value.to_s, IGNORED, FLAGS)
+      Lib.memcached_prepend(@struct, Lib.ns(@namespace, key), value.to_s, IGNORED, FLAGS)
     )
   end
   
@@ -231,7 +233,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   # Deletes a key/value pair from the server. Accepts a String <tt>key</tt>. Raises <b>Memcached::NotFound</b> if the key does not exist.
   def delete(key)
     check_return_code(
-      Rlibmemcached.memcached_delete(@struct, ns(key), IGNORED)
+      Lib.memcached_delete(@struct, Lib.ns(@namespace, key), IGNORED)
     )  
   end
   
@@ -250,14 +252,14 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def get(keys, marshal=true)
     if keys.is_a? Array
       # Multi get
-      keys.map! { |key| ns(key) }
+      keys.map! { |key| Lib.ns(@namespace, key) }
       hash = {}
       
-      Rlibmemcached.memcached_mget(@struct, keys);
+      Lib.memcached_mget(@struct, keys);
       
       keys.size.times do 
-        value, key, flags, ret = Rlibmemcached.memcached_fetch_rvalue(@struct)
-        break if ret == Rlibmemcached::MEMCACHED_END
+        value, key, flags, ret = Lib.memcached_fetch_rvalue(@struct)
+        break if ret == Lib::MEMCACHED_END
         check_return_code(ret)
         value = Marshal.load(value) if marshal
         # Assign the value, removing the namespace, if present
@@ -266,7 +268,7 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
       hash
     else
       # Single get
-      value, flags, ret = Rlibmemcached.memcached_get_rvalue(@struct, ns(keys))
+      value, flags, ret = Lib.memcached_get_rvalue(@struct, Lib.ns(@namespace, keys))
       check_return_code(ret)
       value = Marshal.load(value) if marshal
       value
@@ -279,18 +281,18 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
   def stats
     stats = Hash.new([])
     
-    stat_struct, ret = Rlibmemcached.memcached_stat(@struct, "")
+    stat_struct, ret = Lib.memcached_stat(@struct, "")
     check_return_code(ret)
     
-    keys, ret = Rlibmemcached.memcached_stat_get_keys(@struct, stat_struct)
+    keys, ret = Lib.memcached_stat_get_keys(@struct, stat_struct)
     check_return_code(ret)
     
     keys.each do |key|
        server_structs.size.times do |index|
 
-         value, ret = Rlibmemcached.memcached_stat_get_rvalue(
+         value, ret = Lib.memcached_stat_get_rvalue(
            @struct, 
-           Rlibmemcached.memcached_select_stat_at(@struct, stat_struct, index),
+           Lib.memcached_select_stat_at(@struct, stat_struct, index),
            key)
          check_return_code(ret)
 
@@ -304,19 +306,13 @@ Please note that when non-blocking IO is enabled, setter and deleter methods do
        end
     end
     
-    Rlibmemcached.memcached_stat_free(@struct, stat_struct)
+    Lib.memcached_stat_free(@struct, stat_struct)
     stats
   end  
   
   ### Operations helpers
   
   private
-
-  # Return a namespaced key for this Memcached instance. Accepts a String <tt>key</tt> value.
-  def ns(key) #:doc:
-    # raise ClientError, "Invalid key" if key =~ /\s/ # XXX Slow
-    "#{@namespace}#{key}"
-  end
     
   # 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:

data/lib/memcached/rails.rb

@@ -4,10 +4,6 @@ class Memcached
   alias :get_multi :get #:nodoc:
 
   # A legacy compatibility wrapper for the Memcached class. It has basic compatibility with the <b>memcache-client</b> API.
-  #
-  # There is currently a libmemcached stability issue with long-lived instances, so you will want to call Memcached#reset before each
-  # request (for example, in an ActionController filter).
-  #
   class Rails < ::Memcached
     
     DEFAULTS = {}

data/memcached.gemspec

@@ -1,20 +1,20 @@
 
-# Gem::Specification for Memcached-0.7.1
+# Gem::Specification for Memcached-0.7.2
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.7.1"
+  s.version = "0.7.2"
 
   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-05}
+  s.date = %q{2008-02-10}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]
-  s.files = ["BENCHMARKS", "CHANGELOG", "COMPATIBILITY", "ext/extconf.rb", "ext/rlibmemcached.i", "ext/rlibmemcached_wrap.c", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/integer.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb", "lib/memcached.rb", "LICENSE", "Manifest", "README", "test/profile/benchmark.rb", "test/profile/profile.rb", "test/profile/valgrind.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb", "TODO", "memcached.gemspec"]
+  s.files = ["BENCHMARKS", "CHANGELOG", "COMPATIBILITY", "ext/extconf.rb", "ext/rlibmemcached.i", "ext/rlibmemcached_wrap.c", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/integer.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb", "lib/memcached.rb", "LICENSE", "Manifest", "README", "test/profile/benchmark.rb", "test/profile/key.rb", "test/profile/profile.rb", "test/profile/valgrind.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb", "TODO", "memcached.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/memcached/}
   s.require_paths = ["lib", "ext"]

data/test/profile/key.rb

@@ -0,0 +1,41 @@
+
+HERE = File.dirname(__FILE__)
+$LOAD_PATH << "#{HERE}/../../lib/"
+
+require 'rubygems'
+require 'memcached'
+require 'ruby-prof'
+require 'benchmark'
+
+KEYS = ["ch\303\242teau"*10, "long"*100, "spaces space spaces", "null \000"]
+
+@namespace = "benchmark_namespace"
+@cache = Memcached.new(
+  ['127.0.0.1:43042', '127.0.0.1:43043'], 
+   :namespace => @namespace
+ )
+
+def dispatch(n, k)
+  Rlibmemcached.ns(@namespace, key)
+end
+
+#result = RubyProf.profile do  
+Benchmark.bm(15) do |x|
+  x.report("direct") do
+    KEYS.each do |key|
+      10000.times do
+        Rlibmemcached.ns(@namespace, key)
+      end
+    end
+  end
+  x.report("dispatch") do
+    KEYS.each do |key|
+      10000.times do
+        Rlibmemcached.ns(@namespace, key)
+      end
+    end
+  end
+end
+
+#printer = RubyProf::GraphPrinter.new(result)
+#printer.print(STDOUT, 0)

data/test/profile/profile.rb

@@ -6,6 +6,11 @@ require 'rubygems'
 require 'memcached'
 require 'ruby-prof'
 
+@cache = Memcached.new(
+  '127.0.0.1:43042', '127.0.0.1:43043'], 
+   :namespace => "benchmark_namespace"
+ )
+
 result = RubyProf.profile do  
   load "#{HERE}/valgrind.rb"
 end

data/test/unit/memcached_test.rb

@@ -22,6 +22,12 @@ class MemcachedTest < Test::Unit::TestCase
     @marshalled_value = Marshal.dump(@value)
   end
   
+  def teardown
+    ObjectSpace.each_object(Memcached) do |cache|
+      cache.destroy rescue Memcached::ClientError
+    end
+  end
+  
   # Initialize
 
   def test_initialize
@@ -49,9 +55,9 @@ class MemcachedTest < Test::Unit::TestCase
   
   def test_initialize_with_missing_server
     # XXX Triggers abort trap with libmemcached --enable-debug.
-    @cache = Memcached.new "127.0.0.1:43044"
+    cache = Memcached.new "127.0.0.1:43044"
     assert_raises Memcached::SystemError do
-      @cache.get key
+      cache.get key
     end
   end
 
@@ -121,19 +127,6 @@ class MemcachedTest < Test::Unit::TestCase
     assert result.size > non_wrapped_result.size      
   end  
 
-  def test_get_invalid_key
-    assert_raise(Memcached::ClientError) { @cache.get(key * 100) }
-    # XXX Trying to get Krow to change this to ProtocolError
-    assert_raise(Memcached::NotFound) { @cache.get "I'm so bad" } 
-  end 
-
-  def test_get_multi_invalid_key
-    assert_raise(Memcached::ClientError) { @cache.get([key * 100]) }
-    # XXX Trying to get Krow to change this to ProtocolError
-    assert_equal({}, 
-     @cache.get(["I'm so bad"]))
-  end
-
   def test_get_multi
     @cache.set "#{key}_1", 1
     @cache.set "#{key}_2", 2
@@ -185,13 +178,7 @@ class MemcachedTest < Test::Unit::TestCase
       @cache.set(key, @value)
     end
   end
-  
-  def test_set_invalid_key
-    assert_raise(Memcached::ProtocolError) do
-      @cache.set "I'm so bad", @value
-    end
-  end
-  
+    
   def test_set_expiry
     @cache.set key, @value, 1
     assert_nothing_raised do
@@ -202,12 +189,6 @@ class MemcachedTest < Test::Unit::TestCase
       @cache.get key
     end
   end
-
-  def test_set_object_too_large
-    assert_raise(Memcached::ServerError) do
-      @cache.set key, "I'm big" * 1000000
-    end
-  end
   
   # Delete
   
@@ -362,6 +343,85 @@ class MemcachedTest < Test::Unit::TestCase
     end
   end
   
+  # Namespace and key validation
+  
+  def test_ns
+    assert_equal "#{@namespace}i_have_a_space", 
+      Rlibmemcached.ns(@namespace, "i have a space")     
+
+    # STR2CSTR doesn't handle strings with nulls very well, so this is what happens 
+    assert_equal "#{@namespace}with_____", 
+      Rlibmemcached.ns(@namespace, "with\000null")
+
+    assert_equal "#{@namespace}ch__teau", 
+      Rlibmemcached.ns(@namespace, "ch\303\242teau")
+
+    assert_equal "#{@namespace}#{'x'*251}"[0..249], 
+      Rlibmemcached.ns(@namespace, 'x'*251)
+  end  
+  
+  # Error states
+  
+  def test_key_with_spaces
+    value = "value"
+    key = "i have a space"
+    assert_nothing_raised do
+      @cache.set key, value
+    end
+    assert_nothing_raised do
+      assert_equal(value, @cache.get(key))
+    end
+    # Spaces were stripped
+    assert_not_equal(key,
+      @cache.get([key]).keys.first)
+  end
+  
+  def test_key_with_null
+    value = "value"
+    key = "with\000null"
+    assert_nothing_raised do
+      @cache.set key, value
+    end
+    assert_nothing_raised do
+      assert_equal(value, @cache.get(key))
+    end
+    # Multiget returns
+    response = @cache.get([key])
+    assert_equal 1, response.size
+    # Nulls were stripped    
+    assert_not_equal(key, response.keys.first)
+  end  
+  
+  def test_key_with_valid_control_characters
+    value = "value"
+    key = "ch\303\242teau"
+    @cache.set key, value
+    assert_equal(value, 
+      @cache.get(key))
+    assert_not_equal(key,
+      @cache.get([key]).keys.first)
+  end
+  
+  def test_key_too_long
+    key = "x"*251
+    assert_nothing_raised do    
+      @cache.set key, @value
+    end
+    assert_nothing_raised do
+      assert_equal(@value, 
+        @cache.get(key))  
+    end
+    # Key was truncated
+    assert_not_equal(key,
+      @cache.get([key]).keys.first)
+  end  
+
+  def test_set_object_too_large
+    assert_raise(Memcached::ServerError) do
+      @cache.set key, "I'm big" * 1000000
+    end
+  end
+  
   # Stats
 
   def test_stats

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcached
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors: 
 - Evan Weaver
@@ -30,7 +30,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2008-02-05 00:00:00 -05:00
+date: 2008-02-10 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -59,6 +59,7 @@ files:
 - Manifest
 - README
 - test/profile/benchmark.rb
+- test/profile/key.rb
 - test/profile/profile.rb
 - test/profile/valgrind.rb
 - test/setup.rb

metadata.gz.sig

@@ -1 +1,2 @@
-	RU�^h�����V
�4���t��n'�>��V��	�!������ÔR<>
C��\
+w��/o�+i�&�	A=\����WA�:]�&��_@�	��;
+�.\�6���<3�'��@�sZ����c%)�y�c��;�0���ێ�<F�
�嗯����i�%���w�1��Zl���cNk�:.�	���nWO	'�n[�$�1����G��{\.