dalli 0.9.4 → 0.9.5

data/Gemfile

@@ -3,5 +3,5 @@ source :rubygems
 gemspec
 
 group :test do
-  gem 'simplecov-html'
+  gem 'simplecov'
 end

data/History.md

@@ -1,6 +1,15 @@
 Dalli Changelog
 =====================
 
+HEAD
+-----
+
+ - Major design change - raw support is back to maximize compatibility with Rails
+ and the increment/decrement operations.  You can now pass :raw => true to most methods
+ to bypass (un)marshalling.
+ - Support symbols as keys (ddollar)
+
+
 0.9.4
 -----
 
@@ -23,6 +32,7 @@ Dalli Changelog
 
  - Verify proper operation in Heroku.
 
+
 0.9.1
 ----
 

data/README.md

@@ -91,10 +91,7 @@ Put this at the bottom of `config/environment.rb`:
 Features and Changes
 ------------------------
 
-Dalli is **NOT** 100% API compatible with memcache-client.  If you have code which uses the MemCache
-API directly, it will likely need small tweaks.  Method parameters and return values changed slightly.
-
-memcache-client allowed developers to store either raw or marshalled values with each API call.  I feel this is needless complexity; Dalli allows you to control marshalling per-Client with the `:marshal => false` flag but you cannot explicitly set the raw flag for each API call.  By default, marshalling is enabled.
+Dalli is **NOT** 100% API compatible with memcache-client.  If you have code which uses the MemCache API directly, it will likely need small tweaks.  Method parameters and return values changed slightly.  See Upgrade.md for more detail.
 
 I've removed support for key namespaces and automatic pruning of keys longer than 250 characters.  ActiveSupport::Cache implements these features so there is little need for Dalli to reinvent them.
 
@@ -114,6 +111,10 @@ Thanks
 
 Brian Mitchell - for his remix-stash project which was helpful when implementing and testing the binary protocol support.
 
+[NorthScale](http://northscale.com) - for their project sponsorship
+
+[Bootspring](http://bootspring.com) is my Ruby and Rails consulting company.  We specialize in Ruby infrastructure, performance and scalability tuning for Rails applications.  If you need help, please [contact us](mailto:info@bootspring.com) today.
+
 
 Author
 ----------

data/Rakefile

@@ -9,4 +9,9 @@ Rake::TestTask.new(:bench) do |test|
   test.pattern = 'test/benchmark_test.rb'
 end
 
-task :default => :test
+task :default => :test
+
+task :test_all do
+  system('rake test RAILS_VERSION="~> 2.3.0"')
+  system('rake test RAILS_VERSION="~> 3.0.0"')
+end

data/Upgrade.md

@@ -1,37 +1,26 @@
 Upgrading from memcache-client
 ========
 
-Dalli is not meant to be 100% compatible with memcache-client, there are serveral differences in the API.
+Dalli is not meant to be 100% compatible with memcache-client, there are a few minor differences in the API.
 
 
 Marshalling
 ---------------
 
-Dalli has removed support for specifying the marshalling behavior for each operation.
-
-Take this typical operation:
+Dalli has changed the raw parameter to a :raw option.  The memcache-client API allowed you to control marshalling on a per-method basis using a boolean 'raw' parameter to several of the API methods:
 
     cache = MemCache.new
-    cache.set('abc', 123)
-
-Technically 123 is an Integer and presumably you want `cache.get('abc')` to return an Integer.  Since memcached stores values as binary blobs, Dalli will serialize the value to a binary blob for storage.  When you get() the value back, Ruby will deserialize it properly to an Integer and all will be well.  Without marshalling, Dalli will convert values to Strings and so get() would return a String, not an Integer.
-
-The memcache-client API allowed you to control marshalling on a per-method basis using a boolean 'raw' parameter to several of the API methods:
-
-	cache = MemCache.new
     cache.set('abc', 123, 0, true)
     cache.get('abc', true) => '123'
-  
+
     cache.set('abc', 123, 0)
     cache.get('abc') => 123
 
-Note that the last 'raw' parameter is set to true in the first two API calls and so `get` returns a string, not an integer.  In the second example, we don't provide the raw parameter.  Since it defaults to false, it works exactly like Dalli.
-
-If the code specifies raw as false, you can simply remove that parameter.  If the code is using raw = true, you will need to use the :marshal option to create a Dalli::Client instance that does not perform marshalling:
+Note that the last parameter is set to true in the first two API calls and so `get` returns a string, not an integer.  In the second example, we don't provide the raw parameter.  Since it defaults to false, it works exactly like Dalli.
 
-    cache = Dalli::Client.new(servers, :marshal => false)
+If the code specifies raw as false, you can simply remove that parameter.  If the code is using raw = true, you will need to use the :raw option:
 
-If the code is mixing marshal modes (performing operations where raw is both true and false), you will need to use two different client instances.
+    cache.set('abc', 123, 0, :raw => true)
 
 
 Return Values

data/dalli.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version = Dalli::VERSION
 
   s.authors = ["Mike Perham"]
-  s.date = %q{2010-08-28}
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
   s.description = %q{High performance memcached client for Ruby}
   s.email = %q{mperham@gmail.com}
   s.files = Dir.glob("lib/**/*") + [

data/lib/active_support/cache/dalli_store.rb

@@ -15,13 +15,6 @@ module ActiveSupport
     # DalliStore implements the Strategy::LocalCache strategy which implements
     # an in memory cache inside of a block.
     class DalliStore < Store
-      module Response # :nodoc:
-        STORED      = "STORED\r\n"
-        NOT_STORED  = "NOT_STORED\r\n"
-        EXISTS      = "EXISTS\r\n"
-        NOT_FOUND   = "NOT_FOUND\r\n"
-        DELETED     = "DELETED\r\n"
-      end
 
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/
 
@@ -46,13 +39,9 @@ module ActiveSupport
         options = addresses.extract_options!
         super(options)
 
-        if addresses.first.respond_to?(:get)
-          @data = addresses.first
-        else
-          mem_cache_options = options.dup
-          UNIVERSAL_OPTIONS.each{|name| mem_cache_options.delete(name)}
-          @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
-        end
+        mem_cache_options = options.dup
+        UNIVERSAL_OPTIONS.each{|name| mem_cache_options.delete(name)}
+        @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
 
         extend Strategy::LocalCache
         extend LocalCacheWithRaw
@@ -64,7 +53,7 @@ module ActiveSupport
         options = names.extract_options!
         options = merged_options(options)
         keys_to_names = names.inject({}){|map, name| map[escape_key(namespaced_key(name, options))] = name; map}
-        raw_values = @data.get_multi(keys_to_names.keys)
+        raw_values = @data.get_multi(keys_to_names.keys, options)
         values = {}
         raw_values.each do |key, value|
           entry = deserialize_entry(value)
@@ -111,13 +100,13 @@ module ActiveSupport
       end
 
       def reset
-        @pool.reset
+        @data.reset
       end
 
       protected
         # Read an entry from the cache.
         def read_entry(key, options) # :nodoc:
-          deserialize_entry(@data.get(escape_key(key)))
+          deserialize_entry(@data.get(escape_key(key), options))
         rescue Dalli::DalliError => e
           logger.error("DalliError (#{e}): #{e.message}") if logger
           nil
@@ -132,7 +121,7 @@ module ActiveSupport
             # Set the memcache expire a few minutes in the future to support race condition ttls on read
             expires_in += 5.minutes
           end
-          @data.send(method, escape_key(key), value, expires_in)
+          @data.send(method, escape_key(key), value, expires_in, options)
         rescue Dalli::DalliError => e
           logger.error("DalliError (#{e}): #{e.message}") if logger
           false

data/lib/active_support/cache/dalli_store23.rb

@@ -14,19 +14,11 @@ module ActiveSupport
     # DalliStore implements the Strategy::LocalCache strategy which implements
     # an in memory cache inside of a block.
     class DalliStore < Store
-      module Response # :nodoc:
-        STORED      = "STORED\r\n"
-        NOT_STORED  = "NOT_STORED\r\n"
-        EXISTS      = "EXISTS\r\n"
-        NOT_FOUND   = "NOT_FOUND\r\n"
-        DELETED     = "DELETED\r\n"
-      end
 
       def self.build_mem_cache(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
         addresses = ["localhost"] if addresses.empty?
-        # No need to marshal since we marshal here.
         Dalli::Client.new(addresses, options)
       end
 
@@ -42,13 +34,10 @@ module ActiveSupport
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
-        if addresses.first.respond_to?(:get)
-          @data = addresses.first
-        else
-          mem_cache_options = options.dup
-          @namespace = mem_cache_options.delete(:namespace)
-          @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
-        end
+
+        mem_cache_options = options.dup
+        @namespace = mem_cache_options.delete(:namespace)
+        @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
 
         extend Strategy::LocalCache
       end
@@ -78,26 +67,26 @@ module ActiveSupport
       # to zero.
       def increment(key, amount = 1) # :nodoc:
         log("incrementing", key, amount)
-
-        response = @data.incr(escape_key(key), amount)
-        response == Response::NOT_FOUND ? nil : response
+        @data.incr(escape_key(key), amount)
       rescue Dalli::DalliError
+        logger.error("DalliError (#{e}): #{e.message}")
         nil
       end
+
       # Decrement a cached value. This method uses the memcached decr atomic
       # operator and can only be used on values written with the :raw option.
       # Calling it on a value not stored with :raw will initialize that value
       # to zero.
       def decrement(key, amount = 1) # :nodoc:
         log("decrement", key, amount)
-        response = @data.decr(escape_key(key), amount)
-        response == Response::NOT_FOUND ? nil : response
+        @data.decr(escape_key(key), amount)
       rescue Dalli::DalliError
+        logger.error("DalliError (#{e}): #{e.message}")
         nil
       end
 
       def reset
-        @pool.reset
+        @data.reset
       end
 
       # Clear the entire cache on all memcached servers. This method should
@@ -114,9 +103,9 @@ module ActiveSupport
       # Read an entry from the cache.
       def read(key, options = nil) # :nodoc:
         super
-        value = @data.get(escape_key(key))
+        value = @data.get(escape_key(key), options)
         return nil if value.nil?
-        value = Marshal.load value
+        value = options && options[:raw] ? value : Marshal.load(value)
         value
       rescue Dalli::DalliError => e
         logger.error("DalliError (#{e}): #{e.message}")
@@ -133,8 +122,8 @@ module ActiveSupport
       def write(key, value, options = nil)
         super
         method = options && options[:unless_exist] ? :add : :set
-        value = Marshal.dump value
-        @data.send(method, escape_key(key), value, expires_in(options))
+        value = options && options[:raw] ? value.to_s : Marshal.dump(value)
+        @data.send(method, escape_key(key), value, expires_in(options), options)
       rescue Dalli::DalliError => e
         logger.error("DalliError (#{e}): #{e.message}")
         false

data/lib/dalli.rb

@@ -11,11 +11,12 @@ module Dalli
   class NetworkError < DalliError; end
 
   def self.logger
-    @logger ||= begin
-      (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
-      (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER) ||
-      default_logger
-    end
+    @logger ||= (rails_logger || default_logger)
+  end
+
+  def self.rails_logger
+    (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
+    (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
   end
 
   def self.default_logger

data/lib/dalli/client.rb

@@ -6,7 +6,7 @@ module Dalli
     # the memcached server.  Usage:
     # <pre>
     # Dalli::Client.new(['localhost:11211:10', 'cache-2.example.com:11211:5', '192.168.0.1:22122:5'], 
-    #                   :threadsafe => false, :marshal => false)
+    #                   :threadsafe => true, :failover => true)
     # </pre>
     # servers is an Array of "host:port:weight" where weight allows you to distribute cache unevenly.
     # Both weight and port are optional.
@@ -14,64 +14,62 @@ module Dalli
     # Options:
     #   :failover - if a server is down, store the value on another server.  Default: true.
     #   :threadsafe - ensure that only one thread is actively using a socket at a time. Default: true.
-    #   :marshal - ensure that the value you store is exactly what is returned.  Otherwise you can see this:
-    #        set('abc', 123)
-    #        get('abc') ==> '123'  (Note you set an Integer but got back a String)
-    #      Default: true.
     #
     def initialize(servers=nil, options={})
       @servers = servers
       @options = options
-      self.extend(Dalli::Marshal) unless options[:marshal] == false
     end
     
     #
     # The standard memcached instruction set
     #
 
-    def get(key)
+    def get(key, options=nil)
       resp = perform(:get, key)
-      (!resp || resp == 'Not found') ? nil : deserialize(resp)
+      (!resp || resp == 'Not found') ? nil : deserialize(resp, options)
     end
 
     def get_multi(*keys)
+      return {} if keys.empty?
+      options = nil
+      options = keys.pop if keys.last.is_a?(Hash)
       ring.lock do
         keys.flatten.each do |key|
           perform(:getkq, key)
         end
         values = ring.servers.inject({}) { |hash, s| hash.merge!(s.request(:noop)); hash }
-        values.inject(values) { |memo, (k,v)| memo[k] = deserialize(v); memo }
+        values.inject(values) { |memo, (k,v)| memo[k] = deserialize(v, options); memo }
       end
     end
 
-    def fetch(key, ttl=0)
-      val = get(key)
+    def fetch(key, ttl=0, options=nil)
+      val = get(key, options)
       if val.nil? && block_given?
         val = yield
-        add(key, val, ttl)
+        add(key, val, ttl, options)
       end
       val
     end
 
-    def cas(key, ttl=0, &block)
+    def cas(key, ttl=0, options=nil, &block)
       (value, cas) = perform(:cas, key)
-      value = (!value || value == 'Not found') ? nil : deserialize(value)
+      value = (!value || value == 'Not found') ? nil : deserialize(value, options)
       if value
         newvalue = block.call(value)
-        perform(:add, key, serialize(newvalue), ttl, cas)
+        perform(:add, key, serialize(newvalue, options), ttl, cas)
       end
     end
 
-    def set(key, value, ttl=0)
-      perform(:set, key, serialize(value), ttl)
+    def set(key, value, ttl=0, options=nil)
+      perform(:set, key, serialize(value, options), ttl)
     end
     
-    def add(key, value, ttl=0)
-      perform(:add, key, serialize(value), ttl, 0)
+    def add(key, value, ttl=0, options=nil)
+      perform(:add, key, serialize(value, options), ttl, 0)
     end
 
-    def replace(key, value, ttl=0)
-      perform(:replace, key, serialize(value), ttl)
+    def replace(key, value, ttl=0, options=nil)
+      perform(:replace, key, serialize(value, options), ttl)
     end
 
     def delete(key)
@@ -148,12 +146,14 @@ module Dalli
       )
     end
 
-    def serialize(value)
-      value.to_s
+    def serialize(value, options)
+      options && options[:raw] ? value.to_s : ::Marshal.dump(value)
     end
-    
-    def deserialize(value)
-      value
+
+    def deserialize(value, options)
+      options && options[:raw] ? value : ::Marshal.load(value)
+    rescue TypeError
+      raise Dalli::DalliError, "Invalid marshalled data in memcached: #{value}"
     end
 
     def env_servers
@@ -163,6 +163,10 @@ module Dalli
     # Chokepoint method for instrumentation
     def perform(op, *args)
       key = args.first
+      if key.is_a?(Symbol)
+        key = key.to_s
+        args[0] = key
+      end
       validate_key(key)
       server = ring.server_for_key(key)
       server.request(op, *args)

data/lib/dalli/options.rb

@@ -2,33 +2,6 @@ require 'thread'
 
 module Dalli
 
-  # Auto-marshal all values in/out of memcached.
-  # Otherwise, Dalli will just use to_s on all values.
-  #
-  # Dalli::Client.extend(Dalli::Marshal)
-  #
-  module Marshal
-    def serialize(value)
-      ::Marshal.dump(value)
-    end
-
-    def deserialize(value)
-      begin
-        ::Marshal.load(value)
-      rescue TypeError
-        raise Dalli::DalliError, "Invalid marshalled data in memcached, this happens if you switch the :marshal option and still have old data in memcached: #{value}"
-      end
-    end
-
-    def append(key, value)
-      raise Dalli::DalliError, "Marshalling and append do not work together"
-    end
-
-    def prepend(key, value)
-      raise Dalli::DalliError, "Marshalling and prepend do not work together"
-    end
-  end
-
   # Make Dalli threadsafe by using a lock around all
   # public server methods.
   #

data/lib/dalli/server.rb

@@ -167,7 +167,7 @@ module Dalli
     def cas_response
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
-      (extras, status, count, _, cas) = header.unpack(CAS_HEADER)
+      (extras, type, status, count, _, cas) = header.unpack(CAS_HEADER)
       data = read(count) if count > 0
       if status == 1
         nil
@@ -182,7 +182,7 @@ module Dalli
     def generic_response
       header = read(24)
       raise Dalli::NetworkError, 'No response' if !header
-      (extras, status, count) = header.unpack(NORMAL_HEADER)
+      (extras, type, status, count) = header.unpack(NORMAL_HEADER)
       data = read(count) if count > 0
       if status == 1
         nil
@@ -287,15 +287,15 @@ module Dalli
     end
 
     def split(n)
-      [0xFFFFFFFF & n, n >> 32]
+      [n >> 32, 0xFFFFFFFF & n]
     end
 
     def longlong(a, b)
-      a | (b << 32)
+      (a << 32) | b
     end
 
-    CAS_HEADER = '@4vnNNQ'
-    NORMAL_HEADER = '@4vnN'
+    CAS_HEADER = '@4CCnNNQ'
+    NORMAL_HEADER = '@4CCnN'
     KV_HEADER = '@2n@6nN'
 
     REQUEST = 0x80
@@ -379,7 +379,7 @@ module Dalli
 
     def sasl_authentication(socket)
       init_sasl if !defined?(::SASL)
-      
+
       Dalli.logger.info { "Dalli/SASL authenticating as #{username}" }
 
       # negotiate
@@ -387,7 +387,7 @@ module Dalli
       socket.write(req)
       header = read(24, socket)
       raise Dalli::NetworkError, 'No response' if !header
-      (extras, status, count) = header.unpack(NORMAL_HEADER)
+      (extras, type, status, count) = header.unpack(NORMAL_HEADER)
       raise Dalli::NetworkError, "Unexpected message format: #{extras} #{count}" unless extras == 0 && count > 0
       content = read(count, socket)
       return (Dalli.logger.debug("Authentication not required/supported by server")) if status == 0x81
@@ -403,7 +403,7 @@ module Dalli
 
       header = read(24, socket)
       raise Dalli::NetworkError, 'No response' if !header
-      (extras, status, count) = header.unpack(NORMAL_HEADER)
+      (extras, type, status, count) = header.unpack(NORMAL_HEADER)
       raise Dalli::NetworkError, "Unexpected message format: #{extras} #{count}" unless extras == 0 && count > 0
       content = read(count, socket)
       return Dalli.logger.info("Dalli/SASL: #{content}") if status == 0

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '0.9.4'
+  VERSION = '0.9.5'
 end

data/test/abstract_unit.rb

@@ -1,4 +1,3 @@
-require 'rails'
 # Used to test the full Rails stack.
 # Stolen from the Rails 3.0 source.
 # Needed for the session store tests.

data/test/benchmark_test.rb

@@ -18,6 +18,7 @@ class TestBenchmark < Test::Unit::TestCase
     # 5 and 6 are only used for multiget miss test
     @key5 = "Medium2"*8
     @key6 = "Long3"*40
+    @counter = 'counter'
   end
   
   def test_benchmark
@@ -27,15 +28,15 @@ class TestBenchmark < Test::Unit::TestCase
 
         n = 2500
 
-        @m = Dalli::Client.new(@servers, :marshal => false)
+        @m = Dalli::Client.new(@servers)
         x.report("set:plain:dalli") do
           n.times do
-            @m.set @key1, @marshalled
-            @m.set @key2, @marshalled
-            @m.set @key3, @marshalled
-            @m.set @key1, @marshalled
-            @m.set @key2, @marshalled
-            @m.set @key3, @marshalled
+            @m.set @key1, @marshalled, 0, :raw => true
+            @m.set @key2, @marshalled, 0, :raw => true
+            @m.set @key3, @marshalled, 0, :raw => true
+            @m.set @key1, @marshalled, 0, :raw => true
+            @m.set @key2, @marshalled, 0, :raw => true
+            @m.set @key3, @marshalled, 0, :raw => true
           end
         end
 
@@ -51,15 +52,15 @@ class TestBenchmark < Test::Unit::TestCase
           end
         end
 
-        @m = Dalli::Client.new(@servers, :marshal => false)
+        @m = Dalli::Client.new(@servers)
         x.report("get:plain:dalli") do
           n.times do
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
+            @m.get @key1, :raw => true
+            @m.get @key2, :raw => true
+            @m.get @key3, :raw => true
+            @m.get @key1, :raw => true
+            @m.get @key2, :raw => true
+            @m.get @key3, :raw => true
           end
         end
 
@@ -113,7 +114,18 @@ class TestBenchmark < Test::Unit::TestCase
           end
         end
 
-        assert true
+        @m = Dalli::Client.new(@servers)
+        x.report("incr:ruby:dalli") do
+          n.times do
+            @m.incr @counter, 1, 0, 1
+          end
+          n.times do
+            @m.decr @counter, 1
+          end
+
+          assert_equal 0, @m.incr(@counter, 0)
+        end
+
       end
     end
 

data/test/helper.rb

@@ -1,6 +1,9 @@
 require 'rubygems'
-# require 'simplecov-html'
+# require 'simplecov'
 # SimpleCov.start
+RAILS_VERSION = ENV['RAILS_VERSION'] || '~> 3.0.0'
+#puts "Testing with Rails #{RAILS_VERSION}"
+gem 'rails', RAILS_VERSION
 
 require 'test/unit'
 require 'shoulda'
@@ -12,25 +15,29 @@ require 'dalli'
 class Test::Unit::TestCase
   include MemcachedMock::Helper
 
+  def rails3?
+    RAILS_VERSION =~ /3\.0\./
+  end
+
   def assert_error(error, regexp=nil, &block)
     ex = assert_raise(error, &block)
     assert_match(regexp, ex.message, "#{ex.class.name}: #{ex.message}\n#{ex.backtrace.join("\n\t")}")
   end
 
   def with_activesupport
-    case Rails.version
-    when '3.0.0'
+    case 
+    when rails3?
       require 'active_support/all'
-    # when '2.3.0'
-    #   require 'active_support'
-    #   require 'active_support/cache/dalli_store23'
+    else
+      require 'active_support'
+      require 'active_support/cache/dalli_store23'
     end
     yield
   end
 
   def with_actionpack
-    case Rails.version
-    when '3.0.0'
+    case
+    when rails3?
       require 'action_dispatch'
       require 'action_controller'
     # when '2.3.0'

data/test/test_active_support.rb

@@ -1,5 +1,4 @@
 require 'helper'
-require 'rails'
 
 class TestActiveSupport < Test::Unit::TestCase
   context 'active_support caching' do
@@ -27,13 +26,23 @@ class TestActiveSupport < Test::Unit::TestCase
       end
     end
 
-    should 'support keys with spaces' do
+    should 'support keys with spaces on Rails3' do
       with_activesupport do
         memcached do
           connect
-          dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
-          mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
-          assert_equal mvalue, dvalue
+          case 
+          when rails3?
+            dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
+            mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
+            assert_equal mvalue, dvalue
+          else
+            assert_raises ArgumentError do
+              @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
+            end
+            assert_raises ArgumentError do
+              @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
+            end
+          end
         end
       end
     end      
@@ -81,6 +90,25 @@ class TestActiveSupport < Test::Unit::TestCase
       end
     end
     
+    should 'support increment/decrement commands' do
+      with_activesupport do
+        memcached do
+          connect
+          assert_equal true, @mc.write('counter', 0, :raw => true)
+          assert_equal 1, @mc.increment('counter')
+          assert_equal 2, @mc.increment('counter')
+          assert_equal 1, @mc.decrement('counter')
+          assert_equal "1", @mc.read('counter', :raw => true)
+
+          assert_equal true, @dalli.write('counter', 0, :raw => true)
+          assert_equal 1, @dalli.increment('counter')
+          assert_equal 2, @dalli.increment('counter')
+          assert_equal 1, @dalli.decrement('counter')
+          assert_equal "1", @dalli.read('counter', :raw => true)
+        end
+      end
+    end
+
     should 'support other esoteric commands' do
       with_activesupport do
         memcached do
@@ -89,6 +117,8 @@ class TestActiveSupport < Test::Unit::TestCase
           ds = @dalli.stats
           assert_equal ms.keys.sort, ds.keys.sort
           assert_equal ms[ms.keys.first].keys.sort, ds[ds.keys.first].keys.sort
+
+          @dalli.reset
         end
       end
     end

data/test/test_dalli.rb

@@ -86,6 +86,36 @@ class TestDalli < Test::Unit::TestCase
       end
     end
 
+    should 'support raw incr/decr' do
+      memcached do |client|
+        client.flush
+
+        assert_equal true, client.set('fakecounter', 0, 0, :raw => true)
+        assert_equal 1, client.incr('fakecounter', 1)
+        assert_equal 2, client.incr('fakecounter', 1)
+        assert_equal 3, client.incr('fakecounter', 1)
+        assert_equal 1, client.decr('fakecounter', 2)
+        assert_equal "1", client.get('fakecounter', :raw => true)
+
+        resp = client.incr('mycounter', 0)
+        assert_nil resp
+
+        resp = client.incr('mycounter', 1, 0, 2)
+        assert_equal 2, resp
+        resp = client.incr('mycounter', 1)
+        assert_equal 3, resp
+
+        resp = client.set('rawcounter', 10, 0, :raw => true)
+        assert_equal true, resp
+
+        resp = client.get('rawcounter', :raw => true)
+        assert_equal '10', resp
+
+        resp = client.incr('rawcounter', 1)
+        assert_equal 11, resp
+      end
+    end
+
     should "support incr/decr operations" do
       memcached do |dc|
         dc.flush
@@ -140,6 +170,9 @@ class TestDalli < Test::Unit::TestCase
         assert_not_nil resp
         assert_equal [true, true], resp
 
+        assert_equal true, dc.set(:foo, 'bar')
+        assert_equal 'bar', dc.get(:foo)
+
         resp = dc.get('123')
         assert_equal nil, resp
 
@@ -152,22 +185,19 @@ class TestDalli < Test::Unit::TestCase
         resp = dc.set('123', 'abc')
         assert_equal true, resp
 
-        assert_raises Dalli::DalliError do
-          dc.prepend('123', '0')
-        end
+        dc.prepend('123', '0')
+        dc.append('123', '0')
 
         assert_raises Dalli::DalliError do
-          dc.append('123', '0')
+          resp = dc.get('123')
         end
 
-        resp = dc.get('123')
-        assert_equal 'abc', resp
         dc.close
         dc = nil
 
-        dc = Dalli::Client.new('localhost:19122', :marshal => false)
+        dc = Dalli::Client.new('localhost:19122')
 
-        resp = dc.set('456', 'xyz')
+        resp = dc.set('456', 'xyz', 0, :raw => true)
         assert_equal true, resp
 
         resp = dc.prepend '456', '0'
@@ -176,7 +206,7 @@ class TestDalli < Test::Unit::TestCase
         resp = dc.append '456', '9'
         assert_equal true, resp
 
-        resp = dc.get('456')
+        resp = dc.get('456', :raw => true)
         assert_equal '0xyz9', resp
 
         resp = dc.stats
@@ -251,6 +281,8 @@ class TestDalli < Test::Unit::TestCase
 
       should 'support SASL authentication' do
         memcached(19121, '-S') do |dc|
+          # I get "Dalli::NetworkError: Error authenticating: 32" in OSX
+          # but SASL works on Heroku servers. YMMV.
           assert_equal true, dc.set('abc', 123)
           assert_equal 123, dc.get('abc')
           assert_equal({"localhost:19121"=>{}}, dc.stats)

data/test/test_session_store.rb

@@ -1,5 +1,9 @@
 require 'helper'
 
+if RAILS_VERSION =~ /3\.0\./
+  # Session testing is complex enough that I can't test it in both Rails
+  # 3.0 and 2.3.  Help is welcome.
+
 require 'abstract_unit'
 require 'action_dispatch/middleware/session/dalli_store'
 
@@ -197,4 +201,5 @@ class TestSessionStore < ActionController::IntegrationTest
         yield
       end
     end
+end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 4
-  version: 0.9.4
+  - 5
+  version: 0.9.5
 platform: ruby
 authors: 
 - Mike Perham
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-28 00:00:00 -07:00
+date: 2010-09-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency