memcache-client 1.7.5 → 1.7.6

data/FAQ.rdoc

@@ -27,5 +27,5 @@ You can increase the timeout or disable them completely with the following confi
 
 The latest version of memcached-client is anywhere from 33% to 100% slower than memcached in various benchmarks.  Keep in mind this means that 10,000 get requests take 1.8 sec instead of 1.2 seconds.
 In practice, memcache-client is unlikely to be a bottleneck in your system but there is always going
-to be an overhead to pure Ruby.  Evan's memcached gem is a thin wrapper around a C library, which
-makes it very fast but also difficult to install for some people.
+to be an overhead to pure Ruby.  memcache-client does have the advantage of built-in integration into 
+Rails and should work on non-MRI platforms: JRuby, MacRuby, etc.

data/History.rdoc

@@ -1,3 +1,12 @@
+= 1.7.6 (2009-11-03)
+
+* Reworked socket timeout code due to several customer complaints about timeouts not
+  working 100% of the time since 1.7.3.
+* Add option to configure the namespace separator string, for interop with Perl
+  which does not use a separator character:
+    MemCache.new(servers, :namespace_separator => '')
+* Move to jeweler and gemcutter for RubyGem support.
+
 = 1.7.5 (2009-09-09)
 
 * Fix ruby warnings (josh)

data/Rakefile

@@ -3,22 +3,24 @@ require 'rubygems'
 require 'rake/rdoctask'
 require 'rake/testtask'
 
-task :gem do
-	sh "gem build memcache-client.gemspec"
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "memcache-client"
+    s.summary = s.description = "A Ruby library for accessing memcached."
+    s.email = "mperham@gmail.com"
+    s.homepage = "http://github.com/mperham/memcache-client"
+    s.authors = ['Eric Hodel', 'Robert Cottrell', 'Mike Perham']
+    s.has_rdoc = true
+    s.files = FileList["[A-Z]*", "{lib,test}/**/*", 'performance.txt']
+    s.test_files = FileList["test/test_*.rb"]
+    s.rubyforge_project = 'seattlerb'
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install jeweler"
 end
 
-task :install => [:gem] do
-	sh "sudo gem install memcache-client-*.gem"
-end
-
-task :clean do
-	sh "rm -f memcache-client-*.gem"
-end
-
-task :publish => [:clean, :gem, :install] do
-	require 'lib/memcache'
-	sh "rubyforge add_release seattlerb memcache-client #{MemCache::VERSION} memcache-client-#{MemCache::VERSION}.gem"
-end
 
 Rake::RDocTask.new do |rd|
 	rd.main = "README.rdoc"

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 6
+:major: 1
+:minor: 7

data/lib/memcache.rb

@@ -6,6 +6,26 @@ require 'zlib'
 require 'digest/sha1'
 require 'net/protocol'
 
+begin
+  # Try to use the SystemTimer gem instead of Ruby's timeout library
+  # when running on something that looks like Ruby 1.8.x. See:
+  #   http://ph7spot.com/articles/system_timer
+  # We don't want to bother trying to load SystemTimer on jruby and
+  # ruby 1.9+
+  if defined?(JRUBY_VERSION) || (RUBY_VERSION >= '1.9')
+    require 'timeout'
+    MemCacheTimer = Timeout
+  else
+    require 'system_timer'
+    MemCacheTimer = SystemTimer
+  end
+rescue LoadError => e
+  puts "[memcache-client] Could not load SystemTimer gem, falling back to Ruby's slower/unsafe timeout library: #{e.message}"
+  require 'timeout'
+  MemCacheTimer = Timeout
+end
+
+
 ##
 # A Ruby client library for memcached.
 #
@@ -15,7 +35,10 @@ class MemCache
   ##
   # The version of MemCache you are using.
 
-  VERSION = '1.7.5'
+  VERSION = begin
+    config = YAML.load(File.read(File.dirname(__FILE__) + '/../VERSION.yml'))
+    "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  end
 
   ##
   # Default options for the cache object.
@@ -29,7 +52,8 @@ class MemCache
     :logger       => nil,
     :no_reply     => false,
     :check_size   => true,
-    :autofix_keys => false
+    :autofix_keys => false,
+    :namespace_separator => ':',
   }
 
   ##
@@ -146,6 +170,7 @@ class MemCache
     @logger       = opts[:logger]
     @no_reply     = opts[:no_reply]
     @check_size   = opts[:check_size]
+    @namespace_separator = opts[:namespace_separator]
     @mutex        = Mutex.new if @multithread
 
     logger.info { "memcache-client #{VERSION} #{Array(servers).inspect}" } if logger
@@ -648,7 +673,7 @@ class MemCache
     if namespace.nil? then
       key
     else
-      "#{@namespace}:#{key}"
+      "#{@namespace}#{@namespace_separator}#{key}"
     end
   end
 
@@ -866,7 +891,7 @@ class MemCache
 
   def handle_error(server, error)
     raise error if error.is_a?(MemCacheError)
-    server.close if server
+    server.close if server && server.status == "CONNECTED"
     new_error = MemCacheError.new error.message
     new_error.set_backtrace error.backtrace
     raise new_error
@@ -1016,7 +1041,7 @@ class MemCache
         @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
         @retry  = nil
         @status = 'CONNECTED'
-      rescue SocketError, SystemCallError, IOError => err
+      rescue SocketError, SystemCallError, IOError, Timeout::Error => err
         logger.warn { "Unable to open socket: #{err.class.name}, #{err.message}" } if logger
         mark_dead err
       end
@@ -1025,8 +1050,32 @@ class MemCache
     end
 
     def connect_to(host, port, timeout=nil)
-      io = MemCache::BufferedIO.new(TCPSocket.new(host, port))
+      sock = nil
+      if timeout
+        MemCacheTimer.timeout(timeout) do
+          sock = TCPSocket.new(host, port)
+        end
+      else
+        sock = TCPSocket.new(host, port)
+      end
+
+      io = MemCache::BufferedIO.new(sock)
       io.read_timeout = timeout
+      # Getting reports from several customers, including 37signals,
+      # that the non-blocking timeouts in 1.7.5 don't seem to be reliable.
+      # It can't hurt to set the underlying socket timeout also, if possible.
+      if timeout
+        secs = Integer(timeout)
+        usecs = Integer((timeout - secs) * 1_000_000)
+        optval = [secs, usecs].pack("l_2")
+        begin
+          io.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+          io.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+        rescue Exception => ex
+          # Solaris, for one, does not like/support socket timeouts.
+          @logger.info "[memcache-client] Unable to use raw socket timeouts: #{ex.class.name}: #{ex.message}" if @logger
+        end
+      end
       io
     end
 

data/lib/memcache_util.rb

@@ -0,0 +1,105 @@
+##
+# A utility wrapper around the MemCache client to simplify cache access.  All
+# methods silently ignore MemCache errors.
+# 
+# This API is deprecated, please use the Rails.cache API or your own wrapper API
+# around MemCache.
+
+module Cache
+  
+  ##
+  # Try to return a logger object that does not rely
+  # on ActiveRecord for logging.
+  def self.logger
+    @logger ||= if defined? Rails.logger # Rails 2.1 +
+      Rails.logger
+    elsif defined? RAILS_DEFAULT_LOGGER # Rails 1.2.2 +
+      RAILS_DEFAULT_LOGGER
+    else
+      ActiveRecord::Base.logger # ... very old Rails.
+    end
+  end
+  ##
+  # Returns the object at +key+ from the cache if successful, or nil if either
+  # the object is not in the cache or if there was an error attermpting to
+  # access the cache.
+  #
+  # If there is a cache miss and a block is given the result of the block will
+  # be stored in the cache with optional +expiry+, using the +add+ method rather
+  # than +set+.
+
+  def self.get(key, expiry = 0)
+    start_time = Time.now
+    value = CACHE.get key
+    elapsed = Time.now - start_time
+    logger.debug('MemCache Get (%0.6f)  %s' % [elapsed, key])
+    if value.nil? and block_given? then
+      value = yield
+      add key, value, expiry
+    end
+    value
+  rescue MemCache::MemCacheError => err
+    logger.debug "MemCache Error: #{err.message}"
+    if block_given? then
+      value = yield
+      put key, value, expiry
+    end
+    value
+  end
+
+  ##
+  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
+  # seconds.
+
+  def self.put(key, value, expiry = 0)
+    start_time = Time.now
+    CACHE.set key, value, expiry
+    elapsed = Time.now - start_time
+    logger.debug('MemCache Set (%0.6f)  %s' % [elapsed, key])
+    value
+  rescue MemCache::MemCacheError => err
+    ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
+  end
+
+  ##
+  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
+  # seconds.  If +key+ already exists in cache, returns nil.
+
+  def self.add(key, value, expiry = 0)
+    start_time = Time.now
+    response = CACHE.add key, value, expiry
+    elapsed = Time.now - start_time
+    logger.debug('MemCache Add (%0.6f)  %s' % [elapsed, key])
+    (response == "STORED\r\n") ? value : nil
+  rescue MemCache::MemCacheError => err
+    ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
+  end
+
+  ##
+  # Deletes +key+ from the cache in +delay+ seconds.
+
+  def self.delete(key, delay = nil)
+    start_time = Time.now
+    CACHE.delete key, delay
+    elapsed = Time.now - start_time
+    logger.debug('MemCache Delete (%0.6f)  %s' %
+                                    [elapsed, key])
+    nil
+  rescue MemCache::MemCacheError => err
+    logger.debug "MemCache Error: #{err.message}"
+    nil
+  end
+
+  ##
+  # Resets all connections to MemCache servers.
+
+  def self.reset
+    CACHE.reset
+    logger.debug 'MemCache Connections Reset'
+    nil
+  end
+
+end
+

data/performance.txt

@@ -0,0 +1,143 @@
+== 1.5.0, 1.8.6 (default in Rails 2.2 and lower)
+
+                                     user     system      total        real
+set:plain:memcache-client       41.550000   0.590000  42.140000 ( 43.740685)
+set:ruby:memcache-client        41.540000   0.590000  42.130000 ( 43.733796)
+get:plain:memcache-client       41.920000   0.610000  42.530000 ( 44.031005)
+get:ruby:memcache-client        41.940000   0.600000  42.540000 ( 44.082447)
+multiget:ruby:memcache-client   46.120000   0.440000  46.560000 ( 47.354041)
+missing:ruby:memcache-client    41.490000   0.580000  42.070000 ( 43.610837)
+mixed:ruby:memcache-client      83.820000   1.190000  85.010000 ( 88.117077)
+
+
+== 1.7.0, timeout, 1.8.6 (closest to default in Rails 2.3)
+                                     user     system      total        real
+set:plain:memcache-client        4.320000   2.280000   6.600000 (  7.102900)
+set:ruby:memcache-client         4.400000   2.300000   6.700000 (  6.856992)
+get:plain:memcache-client        9.890000   6.830000  16.720000 ( 16.984208)
+get:ruby:memcache-client        10.040000   6.890000  16.930000 ( 17.141128)
+multiget:ruby:memcache-client    5.350000   4.110000   9.460000 (  9.542898)
+missing:ruby:memcache-client     4.710000   3.180000   7.890000 (  8.030969)
+mixed:ruby:memcache-client      14.540000   9.200000  23.740000 ( 24.121824)
+
+== 1.7.0, timeout, system_timer, 1.8.6
+                                     user     system      total        real
+set:plain:memcache-client        3.840000   0.640000   4.480000 (  4.643790)
+set:ruby:memcache-client         3.930000   0.650000   4.580000 (  4.731868)
+get:plain:memcache-client        8.320000   1.290000   9.610000 (  9.903877)
+get:ruby:memcache-client         8.460000   1.310000   9.770000 (  9.986694)
+multiget:ruby:memcache-client    4.250000   0.560000   4.810000 (  4.935326)
+missing:ruby:memcache-client     3.840000   0.640000   4.480000 (  4.569696)
+mixed:ruby:memcache-client      12.400000   1.960000  14.360000 ( 14.857924)
+
+== 1.7.0, timeout, 1.9.1
+                                     user     system      total        real
+set:plain:memcache-client        2.130000   2.150000   4.280000 (  3.774238)
+set:ruby:memcache-client         2.230000   2.230000   4.460000 (  3.883686)
+get:plain:memcache-client        4.030000   4.250000   8.280000 (  6.702740)
+get:ruby:memcache-client         4.090000   4.220000   8.310000 (  6.749134)
+multiget:ruby:memcache-client    1.960000   1.840000   3.800000 (  3.089448)
+missing:ruby:memcache-client     2.110000   2.210000   4.320000 (  3.659019)
+mixed:ruby:memcache-client       6.400000   6.560000  12.960000 ( 11.116317)
+
+== 1.7.0, no timeout, 1.9.1
+                                     user     system      total        real
+set:plain:memcache-client        0.560000   0.320000   0.880000 (  1.849380)
+set:ruby:memcache-client         0.630000   0.320000   0.950000 (  1.968208)
+get:plain:memcache-client        0.640000   0.330000   0.970000 (  1.962473)
+get:ruby:memcache-client         0.690000   0.320000   1.010000 (  2.002295)
+multiget:ruby:memcache-client    0.460000   0.110000   0.570000 (  0.885827)
+missing:ruby:memcache-client     0.530000   0.320000   0.850000 (  1.721371)
+mixed:ruby:memcache-client       1.340000   0.660000   2.000000 (  3.973213)
+
+== 1.7.0, no timeout, 1.8.6
+                                     user     system      total        real
+set:plain:memcache-client        1.220000   0.310000   1.530000 (  2.763310)
+set:ruby:memcache-client         1.270000   0.300000   1.570000 (  2.806251)
+get:plain:memcache-client        1.400000   0.300000   1.700000 (  2.944343)
+get:ruby:memcache-client         1.450000   0.310000   1.760000 (  2.997234)
+multiget:ruby:memcache-client    1.120000   0.110000   1.230000 (  1.665716)
+missing:ruby:memcache-client     1.160000   0.300000   1.460000 (  2.683376)
+mixed:ruby:memcache-client       2.760000   0.610000   3.370000 (  5.851047)
+
+== 1.7.1, timeout, 1.8.6, raw + gets SystemTimer
+                                     user     system      total        real
+set:plain:memcache-client        2.670000   0.510000   3.180000 (  3.489509)
+set:ruby:memcache-client         2.810000   0.530000   3.340000 (  3.675955)
+get:plain:memcache-client        4.380000   0.720000   5.100000 (  5.400587)
+get:ruby:memcache-client         4.490000   0.730000   5.220000 (  5.477543)
+multiget:ruby:memcache-client    2.570000   0.310000   2.880000 (  3.034944)
+missing:ruby:memcache-client     2.800000   0.530000   3.330000 (  3.547073)
+mixed:ruby:memcache-client       7.460000   1.250000   8.710000 (  9.272177)
+
+== 1.7.1, timeout, 1.9.1, raw + gets Timeout
+                                     user     system      total        real
+set:plain:memcache-client        1.370000   1.300000   2.670000 (  2.708669)
+set:ruby:memcache-client         1.400000   1.240000   2.640000 (  2.713737)
+get:plain:memcache-client        2.070000   2.020000   4.090000 (  3.950879)
+get:ruby:memcache-client         2.160000   2.090000   4.250000 (  3.924613)
+multiget:ruby:memcache-client    1.080000   0.820000   1.900000 (  1.744107)
+missing:ruby:memcache-client     1.330000   1.270000   2.600000 (  2.547597)
+mixed:ruby:memcache-client       3.540000   3.270000   6.810000 (  6.735349)
+
+== 1.7.1, timeout, 1.8.6, raw + gets SystemTimer, native binary search
+                                     user     system      total        real
+set:plain:memcache-client        1.840000   0.450000   2.290000 (  2.651285)
+set:ruby:memcache-client         1.960000   0.460000   2.420000 (  2.712650)
+get:plain:memcache-client        3.180000   0.630000   3.810000 (  4.079930)
+get:ruby:memcache-client         3.290000   0.640000   3.930000 (  4.242648)
+multiget:ruby:memcache-client    1.640000   0.250000   1.890000 (  2.003687)
+missing:ruby:memcache-client     1.940000   0.450000   2.390000 (  2.619675)
+mixed:ruby:memcache-client       5.360000   1.100000   6.460000 (  7.040998)
+
+== 1.7.2, timeout, 1.8.6, SystemTimer, native binary search
+                                     user     system      total        real
+set:plain:memcache-client        3.260000   0.590000   3.850000 (  4.067382)
+set:ruby:memcache-client         3.370000   0.590000   3.960000 (  4.364004)
+get:plain:memcache-client        6.740000   1.240000   7.980000 (  8.586676)
+get:ruby:memcache-client         6.780000   1.210000   7.990000 (  8.423400)
+multiget:ruby:memcache-client    3.480000   0.540000   4.020000 (  4.288633)
+missing:ruby:memcache-client     3.250000   0.590000   3.840000 (  4.043602)
+mixed:ruby:memcache-client      10.150000   1.810000  11.960000 ( 12.372054)
+
+== 1.7.4, 1.8.6, buffered and non-blocking IO
+                                     user     system      total        real
+set:plain:memcache-client        2.450000   0.790000   3.240000 (  3.397091)
+set:ruby:memcache-client         2.490000   0.790000   3.280000 (  3.555436)
+get:plain:memcache-client        2.840000   0.810000   3.650000 (  3.759695)
+get:ruby:memcache-client         2.890000   0.790000   3.680000 (  3.778011)
+multiget:ruby:memcache-client    1.380000   0.280000   1.660000 (  1.695290)
+missing:ruby:memcache-client     2.380000   0.780000   3.160000 (  3.251136)
+mixed:ruby:memcache-client       5.360000   1.600000   6.960000 (  7.189314)
+
+== memcached 0.13 + libmemcached 0.25.4 versus memcache-client 1.7.4
+
+                                     user     system      total        real
+set:plain:noblock:memcached      0.090000   0.030000   0.120000 (  0.277929)
+set:plain:memcached              0.220000   0.270000   0.490000 (  1.251547)
+set:plain:memcache-client        0.610000   0.270000   0.880000 (  1.670718)
+set:ruby:noblock:memcached       0.150000   0.020000   0.170000 (  0.309201)
+set:ruby:memcached               0.300000   0.290000   0.590000 (  1.390354)
+set:ruby:memcache-client         0.670000   0.270000   0.940000 (  1.713558)
+get:plain:memcached              0.240000   0.270000   0.510000 (  1.169909)
+get:plain:memcache-client        0.850000   0.270000   1.120000 (  1.885270)
+get:ruby:memcached               0.270000   0.280000   0.550000 (  1.229705)
+get:ruby:memcache-client         0.890000   0.260000   1.150000 (  1.861660)
+multiget:ruby:memcached          0.190000   0.090000   0.280000 (  0.396264)
+multiget:ruby:memcache-client    0.530000   0.100000   0.630000 (  0.901016)
+missing:ruby:memcached           0.280000   0.290000   0.570000 (  1.254400)
+missing:ruby:memcached:inline    0.300000   0.290000   0.590000 (  1.235122)
+missing:ruby:memcache-client     0.570000   0.250000   0.820000 (  1.461293)
+mixed:ruby:noblock:memcached     0.540000   0.620000   1.160000 (  2.429200)
+mixed:ruby:memcached             0.580000   0.570000   1.150000 (  2.610819)
+mixed:ruby:memcache-client       1.580000   0.540000   2.120000 (  3.632775)
+
+== 1.7.6, 1.8.7 64-bit (Snow Leopard), SystemTimer
+                                     user     system      total        real
+set:plain:memcache-client        3.070000   0.380000   3.450000 (  3.643275)
+set:ruby:memcache-client         3.140000   0.370000   3.510000 (  3.698602)
+get:plain:memcache-client        3.480000   0.360000   3.840000 (  3.983941)
+get:ruby:memcache-client         3.540000   0.360000   3.900000 (  4.034308)
+multiget:ruby:memcache-client    1.690000   0.140000   1.830000 (  1.889290)
+missing:ruby:memcache-client     3.070000   0.360000   3.430000 (  3.571754)
+mixed:ruby:memcache-client       6.720000   0.750000   7.470000 (  7.838771)

data/test/test_benchmark.rb

@@ -0,0 +1,134 @@
+HERE = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{HERE}/../lib"
+#$LOAD_PATH << "/Library/Ruby/Gems/1.8/gems/activesupport-2.2.2/lib/active_support/vendor/memcache-client-1.5.1"
+
+require 'benchmark'
+require 'rubygems'
+require 'test/unit'
+
+$TESTING = true
+require 'memcache' if not defined?(MemCache)
+
+class TestBenchmark < Test::Unit::TestCase
+
+  def setup
+    puts "Testing #{MemCache::VERSION}"
+    # We'll use a simple @value to try to avoid spending time in Marshal,
+    # which is a constant penalty that both clients have to pay
+    @value = []
+    @marshalled = Marshal.dump(@value)
+    
+    @opts = [
+      ['127.0.0.1:11211', 'localhost:11211'],
+      {
+        :namespace => "namespace",
+#        :no_reply => true,
+#        :timeout => nil,
+      }
+    ]
+    @key1 = "Short"
+    @key2 = "Sym1-2-3::45"*8
+    @key3 = "Long"*40
+    @key4 = "Medium"*8
+    # 5 and 6 are only used for multiget miss test
+    @key5 = "Medium2"*8 
+    @key6 = "Long3"*40 
+  end
+
+  def test_benchmark
+    Benchmark.bm(31) do |x|
+    
+      n = 2500
+#      n = 1000
+    
+      @m = MemCache.new(*@opts)
+      x.report("set:plain:memcache-client") do
+        n.times do
+          @m.set @key1, @marshalled, 0, true
+          @m.set @key2, @marshalled, 0, true
+          @m.set @key3, @marshalled, 0, true
+          @m.set @key1, @marshalled, 0, true
+          @m.set @key2, @marshalled, 0, true
+          @m.set @key3, @marshalled, 0, true
+        end
+      end
+    
+      @m = MemCache.new(*@opts)
+      x.report("set:ruby:memcache-client") do
+        n.times do
+          @m.set @key1, @value
+          @m.set @key2, @value
+          @m.set @key3, @value
+          @m.set @key1, @value
+          @m.set @key2, @value
+          @m.set @key3, @value
+        end
+      end
+    
+      @m = MemCache.new(*@opts)
+      x.report("get:plain:memcache-client") do
+        n.times do
+          @m.get @key1, true
+          @m.get @key2, true
+          @m.get @key3, true
+          @m.get @key1, true
+          @m.get @key2, true
+          @m.get @key3, true
+        end
+      end
+    
+      @m = MemCache.new(*@opts)
+      x.report("get:ruby:memcache-client") do
+        n.times do
+          @m.get @key1
+          @m.get @key2
+          @m.get @key3
+          @m.get @key1
+          @m.get @key2
+          @m.get @key3
+        end
+      end
+
+      @m = MemCache.new(*@opts)
+      x.report("multiget:ruby:memcache-client") do
+        n.times do
+          # We don't use the keys array because splat is slow
+          @m.get_multi @key1, @key2, @key3, @key4, @key5, @key6
+        end
+      end
+    
+      @m = MemCache.new(*@opts)
+      x.report("missing:ruby:memcache-client") do
+        n.times do
+          begin @m.delete @key1; rescue; end
+          begin @m.get @key1; rescue; end
+          begin @m.delete @key2; rescue; end
+          begin @m.get @key2; rescue; end
+          begin @m.delete @key3; rescue; end
+          begin @m.get @key3; rescue; end
+        end
+      end
+          
+      @m = MemCache.new(*@opts)
+      x.report("mixed:ruby:memcache-client") do
+        n.times do
+          @m.set @key1, @value
+          @m.set @key2, @value
+          @m.set @key3, @value
+          @m.get @key1
+          @m.get @key2
+          @m.get @key3
+          @m.set @key1, @value
+          @m.get @key1
+          @m.set @key2, @value
+          @m.get @key2
+          @m.set @key3, @value
+          @m.get @key3
+        end
+      end
+
+      assert true
+    end
+
+  end
+end

data/test/test_mem_cache.rb

@@ -1100,6 +1100,25 @@ class TestMemCache < Test::Unit::TestCase
     assert_match(/test value/, output)
   end
 
+  def test_namespace_separator
+    cache = MemCache.new :namespace => 'ns', :namespace_separator => ''
+
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+
+    cache.servers = []
+    cache.servers << server
+
+    assert_nothing_raised do
+      cache.set "test", "test value"
+    end
+
+    output = server.socket.written.string
+    assert_match(/set nstest/, output)
+    assert_match(/test value/, output)
+  end
+
   def test_basic_unthreaded_operations_should_work
     cache = MemCache.new :multithread => false,
                          :namespace => 'my_namespace',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.7.5
+  version: 1.7.6
 platform: ruby
 authors: 
 - Eric Hodel
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-09 00:00:00 -05:00
+date: 2009-11-03 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -21,23 +21,29 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
 files: 
 - FAQ.rdoc
-- README.rdoc
-- LICENSE.txt
 - History.rdoc
+- LICENSE.txt
+- README.rdoc
 - Rakefile
-- lib/memcache.rb
+- VERSION.yml
 - lib/continuum_native.rb
+- lib/memcache.rb
+- lib/memcache_util.rb
+- performance.txt
+- test/test_benchmark.rb
+- test/test_mem_cache.rb
 has_rdoc: true
 homepage: http://github.com/mperham/memcache-client
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -60,4 +66,5 @@ signing_key:
 specification_version: 3
 summary: A Ruby library for accessing memcached.
 test_files: 
+- test/test_benchmark.rb
 - test/test_mem_cache.rb