em-redis 0.1.1

data/History.txt

@@ -0,0 +1,11 @@
+== 0.1.1 / 2009-05-01
+
+* added a number of aliases to redis-based method names
+* refactored process_cmd method for greater clarity
+
+== 0.1.0 / 2009-04-28
+
+* initial release
+* compatible with Redis 0.093
+
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.rdoc
+em-redis.gemspec
+Rakefile
+lib/em-redis.rb
+lib/em-redis/redis_protocol.rb
+spec/test_helper.rb
+spec/live_redis_protocol_spec.rb
+spec/redis_protocol_spec.rb

data/README.rdoc

@@ -0,0 +1,94 @@
+== EM-REDIS
+
+== DESCRIPTION:
+
+An EventMachine[http://rubyeventmachine.com/] based library for interacting with the very cool Redis[http://code.google.com/p/redis/] data store by Salvatore 'antirez' Sanfilippo.
+Modeled after eventmachine's implementation of the memcached protocol, and influenced by Ezra Zygmuntowicz's {redis-rb}[http://github.com/ezmobius/redis-rb/tree/master] library (distributed as part of Redis).
+
+This library is only useful when used as part of an application that relies on
+Event Machine's event loop.  It implements an EM-based client protocol, which
+leverages the non-blocking nature of the EM interface to acheive significant
+parallelization without threads.
+
+WARNING: this library is my first attempt to write an evented client protocol,
+and isn't currently used in production anywhere.  All that bit in the license
+about not being warranted to work for any particular purpose really applies.
+
+
+== FEATURES/PROBLEMS:
+
+* Implements most Redis commands (see {the list of available commands here}[http://code.google.com/p/redis/wiki/CommandReference] with the notable
+exception of MONITOR and AUTH 
+
+== TODO:
+
+* Right now method names are identical to Redis command names.  I'll add some nice aliases soon.
+* I'm sure multibulk responses can be handled more elegantly 
+* Better default error handling?  Provide a default response block?
+
+== SYNOPSIS:
+
+* Like any Deferrable eventmachine-based protocol implementation, using EM-Redis involves making calls and passing blocks that serve as callbacks when
+the call returns.  
+
+  require 'em-redis'
+
+  EM.run do
+    redis = EM::Protocol::Redis.connect
+    error_callback = lambda {|code| puts "Error code: #{code}" }
+    redis.on_error error_callback
+    redis.set "a", "foo" do |response|
+      redis.get "a" do |response|
+        puts response
+      end
+    end
+  end
+
+* To run live tests on a Redis server (currently compatible with 0.91)
+  
+  rake redis:live_test
+
+* To run a test of the underlying protocol implemention
+
+  rake redis:offline_test
+
+Because the EM::Protocol::Memcached code used Bacon for testing, test code is
+currently in the form of bacon specs.  I'll port them to RSpec at some point.
+
+== REQUIREMENTS:
+
+* Redis (download[http://code.google.com/p/redis/downloads/list])
+
+== INSTALL:
+
+* sudo gem install madsimian-em-redis --source http://gems.github.com
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== CREDIT
+
+    by Jonathan Broad (http://www.relativepath.org)
+

data/Rakefile

@@ -0,0 +1,26 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  load 'tasks/setup.rb'
+end
+
+ensure_in_path 'lib'
+require 'em-redis'
+
+task :default => 'spec:run'
+
+PROJ.name = 'em-redis'
+PROJ.authors = 'Jonathan Broad'
+PROJ.email = 'jonathan@relativepath.org'
+PROJ.url = ''
+PROJ.version = EMRedis::VERSION
+PROJ.rubyforge.name = 'em-redis'
+PROJ.spec.opts << '--color'
+PROJ.gem.dependencies << "bacon"
+
+# EOF

data/em-redis.gemspec

@@ -0,0 +1,35 @@
+Gem::Specification.new do |s|
+  s.name = %q{em-redis}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jonathan Broad"]
+  s.date = %q{2009-04-28}
+  s.description = %q{An EventMachine[http://rubyeventmachine.com/] based library for interacting with the very cool Redis[http://code.google.com/p/redis/] data store by Salvatore 'antirez' Sanfilippo. Modeled after eventmachine's implementation of the memcached protocol, and influenced by Ezra Zygmuntowicz's {redis-rb}[http://github.com/ezmobius/redis-rb/tree/master] library (distributed as part of Redis).  This library is only useful when used as part of an application that relies on Event Machine's event loop.  It implements an EM-based client protocol, which leverages the non-blocking nature of the EM interface to acheive significant parallelization without threads.  WARNING: this library is my first attempt to write an evented client protocol, and isn't currently used in production anywhere.  All that bit in the license about not being warranted to work for any particular purpose really applies.}
+  s.email = %q{jonathan@relativepath.org}
+  s.extra_rdoc_files = ["History.txt", "README.rdoc"]
+  s.files = ["History.txt", "Manifest.txt", "README.rdoc", "em-redis.gemspec", "Rakefile", "lib/em-redis.rb", "lib/em-redis/redis_protocol.rb", "spec/test_helper.rb", "spec/live_redis_protocol_spec.rb", "spec/redis_protocol_spec.rb"]
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{em-redis}
+  s.rubygems_version = %q{1.3.0}
+  s.summary = %q{An EventMachine[http://rubyeventmachine}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bacon>, [">= 0"])
+      s.add_development_dependency(%q<bones>, [">= 2.1.1"])
+    else
+      s.add_dependency(%q<bacon>, [">= 0"])
+      s.add_dependency(%q<bones>, [">= 2.1.1"])
+    end
+  else
+    s.add_dependency(%q<bacon>, [">= 0"])
+    s.add_dependency(%q<bones>, [">= 2.1.1"])
+  end
+end
+

data/lib/em-redis.rb

@@ -0,0 +1,36 @@
+
+module EMRedis
+
+  # :stopdoc:
+  VERSION = '0.1.1'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+end  # module EMRedis
+
+require File.join(EMRedis.libpath, "em-redis/redis_protocol")
+
+# EOF

data/lib/em-redis/redis_protocol.rb

@@ -0,0 +1,479 @@
+require 'rubygems'
+require 'eventmachine'
+
+module EventMachine
+  module Protocols
+    module Redis
+      include EM::Deferrable
+
+      ##
+      # constants
+      #########################
+
+      unless defined? C_ERR
+        C_ERR = "-".freeze
+        C_OK = 'OK'.freeze
+        C_SINGLE = '+'.freeze
+        C_BULK   = '$'.freeze
+        C_MULTI  = '*'.freeze
+        C_INT    = ':'.freeze
+        C_DELIM  = "\r\n".freeze
+      end
+
+      #QUIT, AUTH (NOT IMPLEMENTED) 
+      def quit(&blk)
+        inline_command "QUIT", &blk
+      end
+      
+      #GET,SET,MGET,SETNX,INCR,INCRBY,DECR,DECRBY,EXISTS,DEL,TYPE
+      def type(key, &blk)
+        inline_command "TYPE", key, &blk 
+      end
+
+      def del(key, &blk) #delete
+        inline_command "DEL", key, &blk
+      end
+      alias_method :delete, :del
+
+      def exists(key, &blk) #exists?
+        inline_command "EXISTS", key, &blk
+      end
+      alias_method :exists?, :exists
+
+      def decrby(key, value, &blk) #decrement_by
+        inline_command "DECRBY", key, value, &blk
+      end
+      alias_method :decrement_by, :decrby
+
+      def decr(key, &blk) #decrement
+        inline_command "DECR", key, &blk
+      end
+      alias_method :decrement, :decr
+
+      def incrby(key, value, &blk)
+        inline_command "INCRBY", key, value, &blk
+      end
+      alias_method :increment_by, :incrby
+
+      def incr(key, &blk) #increment
+        inline_command "INCR", key, &blk
+      end
+      alias_method :increment, :incr
+
+      def setnx(key, value, &blk) #set_if_nil
+        multiline_command "SETNX", key, value, &blk
+      end
+      alias_method :set_if_nil, :setnx
+
+      def mget(*keys, &blk) #multi_get
+        inline_command "MGET", *keys, &blk
+      end
+      alias_method :multi_get, :mget
+
+      def set(key, value, &blk)
+        multiline_command "SET", key, value, &blk
+      end
+
+      def get(key, &blk)
+        inline_command "GET", key, &blk
+      end
+      
+      #KEYS,RANDOMKEY,RENAME,RENAMENX,DBSIZE,EXPIRE
+      def keys(key_search_string, &blk)
+        wrapper = lambda {|v| blk.call(v.split)} # spec suggests splitting response on whitespace
+        inline_command "KEYS", key_search_string, &wrapper
+      end
+
+      def randomkey(&blk) #random_key, random
+        inline_command "RANDOMKEY", &blk
+      end
+      alias_method :random_key, :randomkey
+      alias_method :random, :randomkey
+
+      def rename(old_name, new_name, &blk)
+        inline_command "RENAME", old_name, new_name, &blk
+      end
+
+      def renamenx(old_name, new_name, &blk) #rename_if_nil
+        inline_command "RENAMENX", old_name, new_name, &blk
+      end
+      alias_method :rename_if_nil, :renamenx
+
+      def dbsize(&blk)
+        inline_command "DBSIZE", &blk
+      end
+
+      def expire(key, time, &blk)
+        inline_command "EXPIRE", key, time, &blk
+      end
+      
+      #RPUSH,LPUSH,LLEN,LRANGE,LTRIM,LINDEX,LSET,LREM,LPOP,RPOP
+      def rpop(key, &blk) # tail_pop, pop
+        inline_command "RPOP", key, &blk
+      end
+      alias_method :tail_pop, :rpop
+      alias_method :pop, :rpop
+
+      def lpop(key, &blk) #head_pop, shift
+        inline_command "LPOP", key, &blk
+      end
+      alias_method :head_pop, :lpop
+      alias_method :shift, :lpop
+
+
+      def lrem(key, value, count=0, &blk) #list_remove
+        multiline_command "LREM", key, count, value, &blk
+      end
+      alias_method :list_remove, :lrem
+
+      def lset(key, index, value, &blk) #list_set
+        multiline_command "LSET", key, index, value, &blk
+      end
+      alias_method :list_set, :lset
+
+      def lindex(key, index, &blk) #list_index, index
+        inline_command "LINDEX", key, index, &blk
+      end
+      alias_method :list_index, :lindex
+      alias_method :index, :lindex
+
+      def ltrim(key, start, ending, &blk) # list_trim, trim
+        inline_command "LTRIM", key, start, ending, &blk
+      end
+      alias_method :list_trim, :ltrim
+      alias_method :trim, :ltrim
+
+      def lrange(key, start, range, &blk) #list_range, range
+        inline_command "LRANGE", key, start, range, &blk
+      end
+      alias_method :list_range, :lrange
+      alias_method :range, :lrange
+
+      def llen(key, &blk) #list_len, len
+        inline_command "LLEN", key, &blk
+      end
+      alias_method :list_len, :llen 
+      alias_method :len, :llen 
+
+      def lpush(key, value, &blk) #head_push, unshift
+        multiline_command "LPUSH", key, value, &blk
+      end
+      alias_method :head_push, :lpush
+      alias_method :unshift, :lpush
+
+      def rpush(key, value, &blk) #tail_push, push
+        multiline_command "RPUSH", key, value, &blk
+      end
+      alias_method :tail_push, :rpush
+      alias_method :push, :rpush
+
+      
+      #SADD,SREM,SCARD,SISMEMBER,SINTER,SINTERSTORE,SUNION,SUNIONSTORE,SMEMBERS
+      def sadd(key, value, &blk) #set_add, add
+        multiline_command "SADD", key, value, &blk
+      end
+      alias_method :set_add, :sadd 
+      alias_method :add, :sadd 
+
+      def srem(key, value, &blk) #set_remove
+        multiline_command "SREM", key, value, &blk
+      end
+      alias_method :set_remove, :srem
+
+      def scard(key, &blk) # set_size
+        inline_command "SCARD", key, &blk
+      end
+      alias_method :set_size, :scard
+
+      def sismember(key, value, &blk) #set_member? member?
+        multiline_command "SISMEMBER", key, value, &blk
+      end
+      alias_method :set_member?, :sismember
+      alias_method :member?, :sismember
+
+      def sinter(*keys, &blk) #intersect
+        inline_command "SINTER", *keys, &blk
+      end
+      alias_method :intersect, :sinter
+
+      def sinterstore(target_key, *keys, &blk) #intersect_and_store
+        inline_command "SINTERSTORE", target_key, *keys, &blk
+      end
+      alias_method :intersect_and_store, :sinterstore
+
+   #  UNION SET MANIP NOT IN RELEASE BUILDS YET
+   ############################################
+   #  
+   #  def sunion(*keys, &blk)
+   #    inline_command "SUNION", *keys, &blk
+   #  end
+   #
+   #  def sunionstore(target_key, *keys, &blk)
+   #    inline_command "SUNIONSTORE", target_key, *keys, &blk
+   #  end
+   #  
+   ############################################
+
+      def smembers(key, &blk) #set_members, members
+        inline_command "SMEMBERS", key, &blk
+      end
+      alias_method :set_members, :smembers
+      alias_method :members, :smembers
+
+      
+      #SELECT,MOVE,FLUSHDB,FLUSHALL
+      def select(db_index, &blk)
+        inline_command "SELECT", db_index, &blk
+      end
+
+      def move(key, dbindex, &blk)
+        inline_command "MOVE", key, dbindex, &blk
+      end
+
+      def flushdb(&blk)
+        inline_command "FLUSHDB", &blk
+      end
+
+      def flushall(&blk)
+        inline_command "FLUSHALL", &blk
+      end
+
+      #SORT
+      def sort(key, by_pattern=nil, start=nil, ending=nil, get_pattern=nil, desc=false, alpha=false, &blk)
+        command = "SORT #{key}"
+        command += " BY #{by_pattern}" if by_pattern
+        command += " LIMIT #{start} #{ending}" if (start && ending)
+        command += " GET #{get_pattern}" if get_pattern
+        command += " DESC" if desc
+        command += " ALPHA" if alpha
+        inline_command command, &blk
+      end
+      
+      #SAVE,BGSAVE,LASTSAVE,SHUTDOWN
+      def shutdown(&blk)
+        inline_command "SHUTDOWN", &blk
+      end
+
+      def lastsave(&blk)
+        inline_command "LASTSAVE", &blk
+      end
+
+      def bgsave(&blk) #background_save, async_save
+        inline_command "BGSAVE", &blk
+      end
+      alias_method :background_save, :bgsave
+      alias_method :async_save, :bgsave
+
+      def save(&blk)
+        inline_command "SAVE", &blk
+      end
+
+      #INFO,MONITOR
+      def info(&blk)
+        wrapper = lambda do |r| 
+          blk.call(
+            r.split.inject({}) {|hash,string| key,value = string.split(":"); hash[key] = value; hash }
+          )
+        end
+        inline_command "INFO", &wrapper
+      end
+      
+      # MONITOR's a bit tricky
+      def monitor
+      end
+
+      def on_error(&blk)
+        @err_cb = blk
+      end
+
+
+      ## 
+      # Generic request methods      
+      #########################
+
+      def inline_command(*args, &blk)
+        callback {
+          command = args.shift
+          blk ||= lambda { } # all cmds must at least have a no-op callback
+          @redis_callbacks << blk 
+          if args.size > 0
+            command += " " 
+            command += args.join(" ")
+          end
+          command += C_DELIM
+          puts "*** sending: #{command}" if $debug
+          send_data command
+        }
+      end
+
+      def multiline_command(command, *args, &blk)
+        callback {
+          data_value = args.pop.to_s
+          blk ||= lambda { } # all cmds must at least have a no-op callback
+          @redis_callbacks << blk 
+          command += " "
+          if args.size > 0
+            command += args.join(" ") 
+            command += " "
+          end
+          command += data_value.size.to_s
+          command += C_DELIM
+          command += data_value
+          command += C_DELIM
+          puts "*** sending: #{command}" if $debug
+          send_data command
+        }
+      end
+
+      
+      ##
+      # errors
+      #########################
+
+      class ParserError < StandardError; end
+      class ProtocolError < StandardError; end
+
+      class RedisError < StandardError
+        attr_accessor :code
+      end
+
+
+      ##
+      # em hooks
+      #########################
+
+      def self.connect host = 'localhost', port = 6379 
+        puts "*** connecting" if $debug
+        EM.connect host, port, self, host, port
+      end
+
+      def initialize host, port = 6379 
+        puts "*** initializing" if $debug
+        @host, @port = host, port
+      end
+
+      def connection_completed
+        puts "*** connection_complete!" if $debug
+        @redis_callbacks = []
+        @values = []
+        @multibulk_n = 0
+
+        @reconnecting = false
+        @connected = true
+        succeed
+      end
+
+      # 19Feb09 Switched to a custom parser, LineText2 is recursive and can cause
+      #         stack overflows when there is too much data.
+      # include EM::P::LineText2
+      def receive_data data
+        (@buffer||='') << data
+        while index = @buffer.index(C_DELIM)
+          begin
+            line = @buffer.slice!(0,index+2)
+            process_cmd line
+          rescue ParserError
+            @buffer[0...0] = line
+            break
+          end
+        end
+      end
+
+      def process_cmd line
+        puts "*** processing #{line}" if $debug
+        # first character of buffer will always be the response type
+        reply_type = line[0].chr 
+        reply_args = line.slice(1..-3) # remove type character and \r\n
+        case reply_type
+
+        # e.g. +OK
+        when C_SINGLE 
+          if cb = @redis_callbacks.shift
+            cb.call( reply_args )
+          end
+
+        # e.g. $3\r\nabc\r\n
+        # 'bulk' is more complex because it could be part of multi-bulk
+        when C_BULK 
+          data_len = Integer( reply_args ) 
+          if data_len == -1 # expect no data; return nil
+            if @multibulk_n > 0 # we're in the middle of a multibulk reply
+              @values << nil
+              if @values.size == @multibulk_n # DING, we're done
+                if cb = @redis_callbacks.shift
+                  cb.call(@values)
+                  @values = []
+                  @multibulk_n = 0
+                end
+              end
+            else 
+              if cb = @redis_callbacks.shift
+                cb.call(nil)
+              end
+            end
+          elsif @buffer.size >= data_len + 2 # buffer is full of expected data
+            if @multibulk_n > 0 # we're in the middle of a multibulk reply
+              @values << @buffer.slice!(0,data_len) 
+              if @values.size == @multibulk_n # DING, we're done
+                if cb = @redis_callbacks.shift
+                  cb.call(@values)
+                  @values = []
+                  @multibulk_n = 0
+                end
+              end
+            else # not multibulk
+              value = @buffer.slice!(0,data_len)
+              if cb = @redis_callbacks.shift
+                cb.call(value)
+              end
+            end
+            @buffer.slice!(0,2) # tossing \r\n
+          else # buffer isn't full or nil
+            # FYI, ParseError puts command back on head of buffer, waits for
+            # more data complete buffer
+            raise ParserError 
+          end
+        #e.g. :8
+        when C_INT
+          if cb = @redis_callbacks.shift
+            cb.call( Integer(reply_args) )
+          end
+        #e.g. *2\r\n$1\r\na\r\n$1\r\nb\r\n 
+        when C_MULTI
+          @multibulk_n = Integer(reply_args)
+          if @multibulk_n == -1
+            if cb = @redis_callbacks.shift
+              cb.call(nil)
+            end
+          end
+        #e.g. -MISSING
+        when C_ERR
+          @redis_callbacks.shift # throw away the cb?
+          if @err_cb
+            @err_cb.call(reply_args)
+          else
+            err = RedisError.new
+            err.code = reply_args
+            raise err, "Redis server returned error code: #{err.code}"
+          end
+        # Whu?
+        else
+          raise ProtocolError, "reply type not recognized: #{line.strip}"
+        end
+      end
+
+      def unbind
+        puts "*** unbinding" if $debug
+        if @connected or @reconnecting
+          EM.add_timer(1){ reconnect @host, @port }
+          @connected = false
+          @reconnecting = true
+          @deferred_status = nil
+        else
+          raise 'Unable to connect to memcached server'
+        end
+      end
+
+    end
+  end
+end

data/spec/live_redis_protocol_spec.rb

@@ -0,0 +1,426 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper.rb")
+
+EM.describe EM::Protocols::Redis, "connected to an empty db" do
+
+  before do
+    @c = EM::Protocols::Redis.connect
+    @c.select "14"
+    @c.flushdb
+  end
+
+  should "be able to set a string value" do
+    @c.set("foo", "bar") do |r|
+      r.should == "OK"
+      done
+    end
+  end
+
+  should "be able to increment the value of a string" do
+    @c.incr "foo" do |r|
+      r.should == 1
+      @c.incr "foo" do |r|
+        r.should == 2
+        done
+      end
+    end
+  end
+  
+  should "be able to increment the value of a string by an amount" do
+    @c.incrby "foo", 10 do |r|
+      r.should == 10
+      done
+    end
+  end
+
+  should "be able to decrement the value of a string" do
+    @c.incr "foo" do |r|
+      r.should == 1
+      @c.decr "foo" do |r|
+        r.should == 0
+        done
+      end
+    end
+  end
+
+  should "be able to decrement the value of a string by an amount" do
+    @c.incrby "foo", 20 do |r|
+      r.should == 20
+      @c.decrby "foo", 10 do |r|
+        r.should == 10
+        done
+      end
+    end
+  end
+
+  should "be able to 'lpush' to a nonexistent list" do
+    @c.lpush("foo", "bar") do |r|
+      r.should == "OK"
+      done
+    end
+  end
+
+  should "be able to 'rpush' to a nonexistent list" do
+    @c.rpush("foo", "bar") do |r|
+      r.should == "OK"
+      done
+    end
+  end
+
+
+  should "be able to get the size of the database" do
+    @c.dbsize do |r|
+      r.should == 0
+      done
+    end
+  end
+
+  should "be able to add a member to a nonexistent set" do
+    @c.sadd("set_foo", "bar") do |r|
+      r.should == 1
+      done
+    end
+  end
+
+  should "be able to get info about the db as a hash" do
+    @c.info do |r|
+      r.should.key? "redis_version"
+      done
+    end
+  end
+
+  should "be able to save db" do
+    @c.save do |r|
+      r.should == "OK"
+      done
+    end
+  end
+
+  should "be able to save db in the background" do
+    @c.bgsave do |r|
+      r.should == "OK"
+      done
+    end
+  end
+
+
+end
+
+EM.describe EM::Protocols::Redis, "connected to a db containing some simple string-valued keys" do
+
+  before do
+    @c = EM::Protocols::Redis.connect
+    @c.select "14"
+    @c.flushdb
+    @c.set "a", "b"
+    @c.set "x", "y"
+  end
+
+  should "be able to fetch the values of multiple keys" do
+    @c.mget "a", "x" do |r|
+      r.should == ["b", "y"]
+      done
+    end
+  end
+
+  should "be able to fetch all the keys" do
+    @c.keys "*" do |r|
+      r.sort.should == ["a", "x"]
+      done
+    end
+  end
+
+  should "be able to set a value if a key doesn't exist" do
+    @c.setnx "a", "foo" do |r|
+      r.should == 0
+      @c.setnx "zzz", "foo" do |r|
+        r.should == 1
+        done
+      end
+    end
+  end
+
+  should "be able to test for the existence of a key" do
+    @c.exists "a" do |r|
+      r.should == 1
+      @c.exists "zzz" do |r|
+        r.should == 0
+        done
+      end
+    end
+  end
+  
+  should "be able to delete a key" do
+    @c.del "a" do |r|
+      r.should == 1
+      @c.exists "a" do |r|
+        r.should == 0
+        @c.del "a" do |r|
+          r.should == 0
+          done
+        end
+      end
+    end
+  end
+
+  should "be able to detect the type of a key, existing or not" do
+    @c.type "a" do |r|
+      r.should == "string"
+      @c.type "zzz" do |r|
+        r.should == "none"
+        done
+      end
+    end
+  end
+
+  should "be able to rename a key" do
+    @c.rename "a", "x" do |r|
+      @c.get "x" do |r|
+        r.should == "b"
+        done
+      end
+    end
+  end
+
+  should "be able to rename a key unless it exists" do
+    @c.renamenx "a", "x" do |r|
+      r.should == 0
+      @c.renamenx "a", "zzz" do |r|
+        r.should == 1
+        @c.get "zzz" do |r|
+          r.should == "b"
+          done
+        end
+      end
+    end
+  end
+
+
+end
+
+EM.describe EM::Protocols::Redis, "connected to a db containing a list" do
+
+  before do
+    @c = EM::Protocols::Redis.connect
+    @c.select "14"
+    @c.flushdb
+    @c.lpush "foo", "c"
+    @c.lpush "foo", "b"
+    @c.lpush "foo", "a"
+  end
+   
+  should "be able to 'lset' a list member and 'lindex' to retrieve it" do
+    @c.lset("foo",  1, "bar") do |r|
+      @c.lindex("foo", 1) do |r|
+        r.should == "bar"
+        done
+      end
+    end
+  end
+
+  should "be able to 'rpush' onto the tail of the list" do
+    @c.rpush "foo", "d" do |r|
+      r.should == "OK"
+      @c.rpop "foo" do |r|
+        r.should == "d"
+        done
+      end
+    end
+  end
+
+  should "be able to 'lpush' onto the head of the list" do
+    @c.lpush "foo", "d" do |r|
+      r.should == "OK"
+      @c.lpop "foo" do |r|
+        r.should == "d"
+        done
+      end
+    end
+  end
+
+  should "be able to 'rpop' off the tail of the list" do
+    @c.rpop("foo") do |r|
+      r.should == "c"
+      done
+    end
+  end
+
+  should "be able to 'lpop' off the tail of the list" do
+    @c.lpop("foo") do |r|
+      r.should == "a"
+      done
+    end
+  end
+
+  should "be able to get a range of values from a list" do
+    @c.lrange("foo", 0,1) do |r|
+      r.should == ["a", "b"]
+      done
+    end
+  end
+
+  should "be able to 'ltrim' a list" do
+    @c.ltrim("foo", 0,1) do |r|
+      r.should == "OK"
+      @c.llen("foo") do |r|
+        r.should == 2
+        done
+      end
+    end
+  end
+
+  should "be able to 'rem' a list element" do
+    @c.lrem("foo", "a", 0) do |r|
+      r.should == 1
+      @c.llen("foo") do |r|
+        r.should == 2
+        done
+      end
+    end
+  end
+
+  should "be able to detect the type of a list" do
+    @c.type "foo" do |r|
+      r.should == "list"
+      done
+    end
+  end
+
+end
+
+EM.describe EM::Protocols::Redis, "connected to a db containing two sets" do
+  before do
+    @c = EM::Protocols::Redis.connect
+    @c.select "14"
+    @c.flushdb
+    @c.sadd "foo", "a"
+    @c.sadd "foo", "b"
+    @c.sadd "foo", "c"
+    @c.sadd "bar", "c"
+    @c.sadd "bar", "d"
+    @c.sadd "bar", "e"
+  end
+
+  should "be able to find a set's cardinality" do
+    @c.scard("foo") do |r|
+      r.should == 3
+      done
+    end
+  end
+
+  should "be able to add a new member to a set unless it is a duplicate" do
+    @c.sadd("foo", "d") do |r|
+      r.should == 1 # success
+      @c.sadd("foo", "a") do |r|
+        r.should == 0 # failure
+        @c.scard("foo") do |r|
+          r.should == 4
+          done
+        end
+      end
+    end
+  end
+
+  should "be able to remove a set member if it exists" do
+    @c.srem("foo", "a") do |r|
+      r.should == 1
+      @c.srem("foo", "z") do |r|
+        r.should == 0
+        @c.scard("foo") do |r|
+          r.should == 2
+          done
+        end
+      end
+    end
+  end
+
+  should "be able to retrieve a set's members" do
+    @c.smembers("foo") do |r|
+      r.sort.should == ["a", "b", "c"]
+      done
+    end
+  end
+
+  should "be able to detect set membership" do
+    @c.sismember("foo", "a") do |r|
+      r.should == 1
+      @c.sismember("foo", "z") do |r|
+        r.should == 0
+        done
+      end
+    end
+  end
+
+  should "be able to find the sets' intersection" do
+    @c.sinter("foo", "bar") do |r|
+      r.should == ["c"]
+      done
+    end
+  end
+
+  should "be able to find and store the sets' intersection" do
+    @c.sinterstore("baz", "foo", "bar") do |r|
+      r.should == 1
+      @c.smembers("baz") do |r|
+        r.should == ["c"]
+        done
+      end
+    end
+  end
+
+# UNION SET MANIP NOT IN RELEASE BUILDS YET
+###########################################
+#
+# should "be able to find the sets' union" do
+#   @c.sunion("foo", "bar") do |r|
+#     r.should == ["a","b","c","d","e"]
+#     done
+#   end
+# end
+
+# should "be able to find and store the sets' union" do
+#   @c.sunionstore("baz", "foo", "bar") do |r|
+#     r.should == "OK"
+#     @c.smembers("baz") do |r|
+#       r.should == ["a","b","c","d","e"]
+#       done
+#     end
+#   end
+# end
+
+  should "be able to detect the type of a set" do
+    @c.type "foo" do |r|
+      r.should == "set"
+      done
+    end
+  end
+
+end
+
+
+EM.describe EM::Protocols::Redis, "connected to a db containing three linked lists" do
+  before do
+    @c = EM::Protocols::Redis.connect
+    @c.select "14"
+    @c.flushdb
+    @c.rpush "foo", "a"
+    @c.rpush "foo", "b"
+    @c.set "a_sort", "2"
+    @c.set "b_sort", "1"
+    @c.set "a_data", "foo"
+    @c.set "b_data", "bar"
+  end
+
+  should "be able to collate a sorted set of data" do
+    @c.sort("foo", "*_sort", nil, nil, "*_data") do |r|
+      r.should == ["bar", "foo"]
+      done
+    end
+  end
+
+  should "be able to get keys selectively" do
+    @c.keys "a_*" do |r|
+      r.should == ["a_sort", "a_data"]
+      done
+    end
+  end
+end

data/spec/redis_protocol_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper.rb")
+
+EM.describe EM::Protocols::Redis do
+
+  before do
+    @c = TestConnection.new
+  end
+
+  # Inline request protocol
+  should 'send inline commands correctly' do
+    @c.inline_command("GET", 'a')
+    @c.sent_data.should == "GET a\r\n"
+    done
+  end
+  
+  should "space-separate multiple inline arguments" do
+    @c.inline_command("GET", 'a', 'b', 'c')
+    @c.sent_data.should == "GET a b c\r\n"
+    done
+  end
+
+  # Multiline request protocol
+  should "send multiline commands correctly" do
+    @c.multiline_command("SET", "foo", "abc")
+    @c.sent_data.should == "SET foo 3\r\nabc\r\n"
+    done
+  end
+
+  should "send integers in multiline commands correctly" do
+    @c.multiline_command("SET", "foo", 1_000_000)
+    @c.sent_data.should == "SET foo 7\r\n1000000\r\n"
+    done
+  end
+
+  # Specific calls
+  #
+  # SORT
+  should "send sort command" do
+    @c.sort "foo"
+    @c.sent_data.should == "SORT foo\r\n"
+    done
+  end
+
+  should "send sort command with all optional parameters" do
+    @c.sort "foo", "foo_sort_*", 0, 10, "data_*", true, true
+    @c.sent_data.should == "SORT foo BY foo_sort_* LIMIT 0 10 GET data_* DESC ALPHA\r\n"
+    done
+  end
+
+  should "parse keys response into an array" do
+    @c.keys "*" do |resp|
+      resp.should == ["a","b","c"]
+      done
+    end
+    @c.receive_data "$5\r\na b c\r\n"
+  end
+
+
+  # Inline response
+  should "parse an inline response" do
+    @c.inline_command("PING") do |resp|
+      resp.should == "OK"
+      done
+    end
+    @c.receive_data "+OK\r\n"
+  end
+
+  should "parse an inline integer response" do
+    @c.inline_command("EXISTS") do |resp|
+      resp.should == 0
+      done
+    end
+    @c.receive_data ":0\r\n"
+  end
+
+  should "parse an inline error response" do
+    lambda do
+      @c.inline_command("BLARG")
+      @c.receive_data "-FAIL\r\n"
+    end.should.raise(EM::P::Redis::RedisError)
+    done
+  end
+
+  should "trigger a given error callback for inline error response instead of raising an error" do
+    lambda do
+      @c.inline_command("BLARG")
+      @c.on_error {|code| code.should == "FAIL"; done }
+      @c.receive_data "-FAIL\r\n"
+    end.should.not.raise(EM::P::Redis::RedisError)
+    done
+  end
+
+  # Bulk response
+  should "parse a bulk response" do
+    @c.inline_command("GET", "foo") do |resp|
+      resp.should == "bar"
+      done
+    end
+    @c.receive_data "$3\r\n"
+    @c.receive_data "bar\r\n"
+  end
+
+  should "distinguish nil in a bulk response" do
+    @c.inline_command("GET", "bar") do |resp|
+      resp.should == nil
+    end
+    @c.receive_data "$-1\r\n"
+  end
+  
+  # Multi-bulk response
+  
+  should "parse a multi-bulk response" do
+    @c.inline_command "RANGE", 0, 10 do |resp|
+      resp.should == ["a", "b", "foo"]
+      done
+    end
+    @c.receive_data "*3\r\n"
+    @c.receive_data "$1\r\na\r\n"
+    @c.receive_data "$1\r\nb\r\n"
+    @c.receive_data "$3\r\nfoo\r\n"
+  end
+
+  should "distinguish nil in a multi-bulk response" do
+    @c.inline_command "RANGE", 0, 10 do |resp|
+      resp.should == ["a", nil, "foo"]
+      done
+    end
+    @c.receive_data "*3\r\n"
+    @c.receive_data "$1\r\na\r\n"
+    @c.receive_data "$-1\r\n"
+    @c.receive_data "$3\r\nfoo\r\n"
+  end
+end

data/spec/test_helper.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/em-redis")
+require 'em-spec/bacon'
+
+EM.spec_backend = EventMachine::Spec::Bacon
+
+class TestConnection
+  include EM::P::Redis
+  def send_data data
+    sent_data << data
+  end
+  def sent_data
+    @sent_data ||= ''
+  end
+
+  def initialize
+    connection_completed
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: em-redis
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jonathan Broad
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-15 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |-
+  An EventMachine[http://rubyeventmachine.com/] based library for interacting with the very cool Redis[http://code.google.com/p/redis/] data store by Salvatore 'antirez' Sanfilippo.
+  Modeled after eventmachine's implementation of the memcached protocol, and influenced by Ezra Zygmuntowicz's {redis-rb}[http://github.com/ezmobius/redis-rb/tree/master] library (distributed as part of Redis).
+  
+  This library is only useful when used as part of an application that relies on
+  Event Machine's event loop.  It implements an EM-based client protocol, which
+  leverages the non-blocking nature of the EM interface to acheive significant
+  parallelization without threads.
+  
+  WARNING: this library is my first attempt to write an evented client protocol,
+  and isn't currently used in production anywhere.  All that bit in the license
+  about not being warranted to work for any particular purpose really applies.
+email: jonathan@relativepath.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- em-redis.gemspec
+- Rakefile
+- lib/em-redis.rb
+- lib/em-redis/redis_protocol.rb
+- spec/test_helper.rb
+- spec/live_redis_protocol_spec.rb
+- spec/redis_protocol_spec.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: em-redis
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An EventMachine[http://rubyeventmachine
+test_files: []
+