em-redis 0.1.1 → 0.2

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/History.txt

@@ -1,3 +1,10 @@
+== 0.2 / 2009-12-??
+* rip off stock redis gem
+* sort is no longer compatible with 0.1 version
+* response of exists, sismember, sadd, srem, smove, zadd, zrem, move, setnx, del, renamenx, and expire is either true of false, not 0/1 as in 0.1
+* info returns hash of symbols now
+* lrem has different argument order
+
 == 0.1.1 / 2009-05-01
 
 * added a number of aliases to redis-based method names

data/README.rdoc

@@ -7,25 +7,15 @@ Modeled after eventmachine's implementation of the memcached protocol, and influ
 
 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
+leverages the non-blocking nature of the EM interface to achieve 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
@@ -44,7 +34,7 @@ the call returns.
     end
   end
 
-* To run live tests on a Redis server (currently compatible with 0.91)
+* To run live tests on a Redis server (currently compatible with 1.02)
   
   rake redis:live_test
 
@@ -61,13 +51,13 @@ currently in the form of bacon specs.  I'll port them to RSpec at some point.
 
 == INSTALL:
 
-* sudo gem install madsimian-em-redis --source http://gems.github.com
+* sudo gem install em-redis
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2008
+Copyright (c) 2008, 2009
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -4,23 +4,29 @@
 
 begin
   require 'bones'
-  Bones.setup
 rescue LoadError
-  load 'tasks/setup.rb'
+  abort '### Please install the "bones" gem ###'
 end
 
 ensure_in_path 'lib'
 require 'em-redis'
 
-task :default => 'spec:run'
+task :default => ['redis:live_test', 'redis:offline_test']
 
-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"
+Bones {
+  name 'em-redis'
+  authors 'Jonathan Broad'
+  email 'jonathan@relativepath.org'
+  url ''
+  version EMRedis::VERSION
+
+  readme_file  'README.rdoc'
+  ignore_file  '.gitignore'
+
+  depend_on 'eventmachine'
+
+  depend_on "bacon", :development => true
+  depend_on "em-spec", :development => true 
+}
 
 # EOF

data/em-redis.gemspec

@@ -1,35 +1,47 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{em-redis}
-  s.version = "0.1.1"
+  s.version = "0.2"
 
   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.date = %q{2009-12-15}
+  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 achieve significant
+parallelization without threads.}
   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.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
+  s.files = [".gitignore", "History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "em-redis.gemspec", "lib/em-redis.rb", "lib/em-redis/redis_protocol.rb", "spec/live_redis_protocol_spec.rb", "spec/redis_protocol_spec.rb", "spec/test_helper.rb", "tasks/em-redis.rake"]
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{em-redis}
-  s.rubygems_version = %q{1.3.0}
+  s.rubygems_version = %q{1.3.5}
   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
+    s.specification_version = 3
 
     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"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.11"])
+      s.add_development_dependency(%q<bacon>, [">= 1.1.0"])
+      s.add_development_dependency(%q<em-spec>, [">= 0.2.0"])
+      s.add_development_dependency(%q<bones>, [">= 3.2.0"])
     else
-      s.add_dependency(%q<bacon>, [">= 0"])
-      s.add_dependency(%q<bones>, [">= 2.1.1"])
+      s.add_dependency(%q<eventmachine>, [">= 0.12.11"])
+      s.add_dependency(%q<bacon>, [">= 1.1.0"])
+      s.add_dependency(%q<em-spec>, [">= 0.2.0"])
+      s.add_dependency(%q<bones>, [">= 3.2.0"])
     end
   else
-    s.add_dependency(%q<bacon>, [">= 0"])
-    s.add_dependency(%q<bones>, [">= 2.1.1"])
+    s.add_dependency(%q<eventmachine>, [">= 0.12.11"])
+    s.add_dependency(%q<bacon>, [">= 1.1.0"])
+    s.add_dependency(%q<em-spec>, [">= 0.2.0"])
+    s.add_dependency(%q<bones>, [">= 3.2.0"])
   end
 end
-

data/lib/em-redis.rb

@@ -2,7 +2,7 @@
 module EMRedis
 
   # :stopdoc:
-  VERSION = '0.1.1'
+  VERSION = '0.2'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:
@@ -29,8 +29,19 @@ module EMRedis
     args.empty? ? PATH : ::File.join(PATH, args.flatten)
   end
 
-end  # module EMRedis
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
 
-require File.join(EMRedis.libpath, "em-redis/redis_protocol")
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module EMRedis
 
-# EOF
+EMRedis.require_all_libs_relative_to(__FILE__)

data/lib/em-redis/redis_protocol.rb

@@ -10,322 +10,252 @@ module EventMachine
       # 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
+      OK      = "OK".freeze
+      MINUS    = "-".freeze
+      PLUS     = "+".freeze
+      COLON    = ":".freeze
+      DOLLAR   = "$".freeze
+      ASTERISK = "*".freeze
+      DELIM    = "\r\n".freeze
+
+      BULK_COMMANDS = {
+        "set"       => true,
+        "setnx"     => true,
+        "rpush"     => true,
+        "lpush"     => true,
+        "lset"      => true,
+        "lrem"      => true,
+        "sadd"      => true,
+        "srem"      => true,
+        "sismember" => true,
+        "rpoplpush" => true,
+        "echo"      => true,
+        "getset"    => true,
+        "smove"     => true,
+        "zadd"      => true,
+        "zrem"      => true,
+        "zscore"    => true
+      }
+
+      MULTI_BULK_COMMANDS = {
+        "mset"      => true,
+        "msetnx"    => true,
+        # these aliases aren't in redis gem
+        "multi_get" => true
+      }
+
+      BOOLEAN_PROCESSOR = lambda{|r| r == 1 }
+
+      REPLY_PROCESSOR = {
+        "exists"    => BOOLEAN_PROCESSOR,
+        "sismember" => BOOLEAN_PROCESSOR,
+        "sadd"      => BOOLEAN_PROCESSOR,
+        "srem"      => BOOLEAN_PROCESSOR,
+        "smove"     => BOOLEAN_PROCESSOR,
+        "zadd"      => BOOLEAN_PROCESSOR,
+        "zrem"      => BOOLEAN_PROCESSOR,
+        "move"      => BOOLEAN_PROCESSOR,
+        "setnx"     => BOOLEAN_PROCESSOR,
+        "del"       => BOOLEAN_PROCESSOR,
+        "renamenx"  => BOOLEAN_PROCESSOR,
+        "expire"    => BOOLEAN_PROCESSOR,
+        "select"    => BOOLEAN_PROCESSOR, # not in redis gem
+        "keys"      => lambda{|r| r.split(" ")},
+        "info"      => lambda{|r|
+          info = {}
+          r.each_line {|kv|
+            k,v = kv.split(":",2).map{|x| x.chomp}
+            info[k.to_sym] = v
+          }
+          info
+        }
+      }
+
+      ALIASES = {
+        "flush_db"             => "flushdb",
+        "flush_all"            => "flushall",
+        "last_save"            => "lastsave",
+        "key?"                 => "exists",
+        "delete"               => "del",
+        "randkey"              => "randomkey",
+        "list_length"          => "llen",
+        "push_tail"            => "rpush",
+        "push_head"            => "lpush",
+        "pop_tail"             => "rpop",
+        "pop_head"             => "lpop",
+        "list_set"             => "lset",
+        "list_range"           => "lrange",
+        "list_trim"            => "ltrim",
+        "list_index"           => "lindex",
+        "list_rm"              => "lrem",
+        "set_add"              => "sadd",
+        "set_delete"           => "srem",
+        "set_count"            => "scard",
+        "set_member?"          => "sismember",
+        "set_members"          => "smembers",
+        "set_intersect"        => "sinter",
+        "set_intersect_store"  => "sinterstore",
+        "set_inter_store"      => "sinterstore",
+        "set_union"            => "sunion",
+        "set_union_store"      => "sunionstore",
+        "set_diff"             => "sdiff",
+        "set_diff_store"       => "sdiffstore",
+        "set_move"             => "smove",
+        "set_unless_exists"    => "setnx",
+        "rename_unless_exists" => "renamenx",
+        "type?"                => "type",
+        "zset_add"             => "zadd",
+        "zset_count"           => 'zcard',
+        "zset_range_by_score"  => 'zrangebyscore',
+        "zset_reverse_range"   => 'zrevrange',
+        "zset_range"           => 'zrange',
+        "zset_delete"          => 'zrem',
+        "zset_score"           => 'zscore',
+        # these aliases aren't in redis gem
+        "background_save"      => 'bgsave',
+        "async_save"           => 'bgsave',
+        "members"              => 'smembers',
+        "decrement_by"         => "decrby",
+        "decrement"            => "decr",
+        "increment_by"         => "incrby",
+        "increment"            => "incr",
+        "set_if_nil"           => "setnx",
+        "multi_get"            => "mget",
+        "random_key"           => "randomkey",
+        "random"               => "randomkey",
+        "rename_if_nil"        => "renamenx",
+        "tail_pop"             => "rpop",
+        "pop"                  => "rpop",
+        "head_pop"             => "lpop",
+        "shift"                => "lpop",
+        "list_remove"          => "lrem",
+        "index"                => "lindex",
+        "trim"                 => "ltrim",
+        "list_range"           => "lrange",
+        "range"                => "lrange",
+        "list_len"             => "llen",
+        "len"                  => "llen",
+        "head_push"            => "lpush",
+        "unshift"              => "lpush",
+        "tail_push"            => "rpush",
+        "push"                 => "rpush",
+        "add"                  => "sadd",
+        "set_remove"           => "srem",
+        "set_size"             => "scard",
+        "member?"              => "sismember",
+        "intersect"            => "sinter",
+        "intersect_and_store"  => "sinterstore",
+        "members"              => "smembers",
+        "exists?"              => "exists"
+      }
+
+      DISABLED_COMMANDS = {
+        "monitor" => true,
+        "sync"    => true
+      }
+
+      def [](key)
+        self.get(key)
+      end
+
+      def []=(key,value)
+        set(key,value)
+      end
+
+      def set(key, value, expiry=nil)
+        call_command([:set, key, value]) do |s|
+          expire(key, expiry) if s == OK && expiry
+          yield s if block_given?
+        end
       end
 
-      def move(key, dbindex, &blk)
-        inline_command "MOVE", key, dbindex, &blk
+      def sort(key, options={}, &blk)
+        cmd = ["SORT"]
+        cmd << key
+        cmd << "BY #{options[:by]}" if options[:by]
+        cmd << "GET #{[options[:get]].flatten * ' GET '}" if options[:get]
+        cmd << "#{options[:order]}" if options[:order]
+        cmd << "LIMIT #{options[:limit].join(' ')}" if options[:limit]
+        call_command(cmd, &blk)
       end
 
-      def flushdb(&blk)
-        inline_command "FLUSHDB", &blk
+      def incr(key, increment = nil, &blk)
+        call_command(increment ? ["incrby",key,increment] : ["incr",key], &blk)
       end
 
-      def flushall(&blk)
-        inline_command "FLUSHALL", &blk
+      def decr(key, decrement = nil, &blk)
+        call_command(decrement ? ["decrby",key,decrement] : ["decr",key], &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
+      # Similar to memcache.rb's #get_multi, returns a hash mapping
+      # keys to values.
+      def mapped_mget(*keys)
+        mget(*keys) do |response|
+          result = {}
+          response.each do |value|
+            key = keys.shift
+            result.merge!(key => value) unless value.nil?
+          end
+          yield result if block_given?
+        end
       end
 
-      def lastsave(&blk)
-        inline_command "LASTSAVE", &blk
+      # Ruby defines a now deprecated type method so we need to override it here
+      # since it will never hit method_missing
+      def type(key, &blk)
+        call_command(['type', key], &blk)
       end
 
-      def bgsave(&blk) #background_save, async_save
-        inline_command "BGSAVE", &blk
+      def quit(&blk)
+        call_command(['quit'], &blk)
       end
-      alias_method :background_save, :bgsave
-      alias_method :async_save, :bgsave
 
-      def save(&blk)
-        inline_command "SAVE", &blk
+      def on_error(&blk)
+        @err_cb = 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
+      def method_missing(*argv, &blk)
+        call_command(argv, &blk)
       end
 
-      def on_error(&blk)
-        @err_cb = blk
+      def call_command(argv, &blk)
+        callback { raw_call_command(argv, &blk) }
       end
 
+      def raw_call_command(argv, &blk)
+        argv = argv.dup
 
-      ## 
-      # 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(" ")
+        if MULTI_BULK_COMMANDS[argv.flatten[0].to_s]
+          # TODO improve this code
+          argvp   = argv.flatten
+          values  = argvp.pop.to_a.flatten
+          argvp   = values.unshift(argvp[0])
+          command = ["*#{argvp.size}"]
+          argvp.each do |v|
+            v = v.to_s
+            command << "$#{get_size(v)}"
+            command << v
           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 += " "
+          command = command.map {|cmd| "#{cmd}\r\n"}.join
+        else
+          command = ""
+          bulk = nil
+          argv[0] = argv[0].to_s.downcase
+          argv[0] = ALIASES[argv[0]] if ALIASES[argv[0]]
+          raise "#{argv[0]} command is disabled" if DISABLED_COMMANDS[argv[0]]
+          if BULK_COMMANDS[argv[0]] and argv.length > 1
+            bulk = argv[-1].to_s
+            argv[-1] = get_size(bulk)
           end
-          command += data_value.size.to_s
-          command += C_DELIM
-          command += data_value
-          command += C_DELIM
-          puts "*** sending: #{command}" if $debug
-          send_data command
-        }
+          command << "#{argv.join(' ')}\r\n"
+          command << "#{bulk}\r\n" if bulk
+        end
+
+        puts "*** sending: #{command}" if $debug
+        @redis_callbacks << [REPLY_PROCESSOR[argv[0]], blk]
+        send_data command
       end
 
-      
       ##
       # errors
       #########################
@@ -342,12 +272,12 @@ module EventMachine
       # em hooks
       #########################
 
-      def self.connect host = 'localhost', port = 6379 
+      def self.connect(host = 'localhost', port = 6379 )
         puts "*** connecting" if $debug
         EM.connect host, port, self, host, port
       end
 
-      def initialize host, port = 6379 
+      def initialize(host, port = 6379 )
         puts "*** initializing" if $debug
         @host, @port = host, port
       end
@@ -366,11 +296,11 @@ module EventMachine
       # 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
+      def receive_data(data)
         (@buffer||='') << data
-        while index = @buffer.index(C_DELIM)
+        while index = @buffer.index(DELIM)
           begin
-            line = @buffer.slice!(0,index+2)
+            line = @buffer.slice!(0, index+2)
             process_cmd line
           rescue ParserError
             @buffer[0...0] = line
@@ -379,53 +309,54 @@ module EventMachine
         end
       end
 
-      def process_cmd line
+      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_type = line[0, 1]
         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 )
+        #e.g. -MISSING
+        when MINUS
+          @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
 
+        # e.g. +OK
+        when PLUS
+          dispatch_response(reply_args)
+
         # 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 ) 
+        when DOLLAR
+          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)
+                dispatch_response(@values)
+                @values = []
+                @multibulk_n = 0
               end
+            else
+              dispatch_response(nil)
             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) 
+              @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
+                dispatch_response(@values)
+                @values = []
+                @multibulk_n = 0
               end
             else # not multibulk
-              value = @buffer.slice!(0,data_len)
-              if cb = @redis_callbacks.shift
-                cb.call(value)
-              end
+              value = @buffer.slice!(0, data_len)
+              dispatch_response(value)
             end
             @buffer.slice!(0,2) # tossing \r\n
           else # buffer isn't full or nil
@@ -433,35 +364,28 @@ module EventMachine
             # more data complete buffer
             raise ParserError 
           end
+
         #e.g. :8
-        when C_INT
-          if cb = @redis_callbacks.shift
-            cb.call( Integer(reply_args) )
-          end
+        when COLON
+          dispatch_response(Integer(reply_args))
+
         #e.g. *2\r\n$1\r\na\r\n$1\r\nb\r\n 
-        when C_MULTI
+        when ASTERISK
           @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
+          dispatch_response(nil) if @multibulk_n == -1
+
         # Whu?
         else
           raise ProtocolError, "reply type not recognized: #{line.strip}"
         end
       end
 
+      def dispatch_response(value)
+        processor, blk = @redis_callbacks.shift
+        value = processor.call(value) if processor
+        blk.call(value) if blk
+      end
+
       def unbind
         puts "*** unbinding" if $debug
         if @connected or @reconnecting
@@ -470,10 +394,15 @@ module EventMachine
           @reconnecting = true
           @deferred_status = nil
         else
-          raise 'Unable to connect to memcached server'
+          raise 'Unable to connect to redis server'
         end
       end
 
+      private
+        def get_size(string)
+          string.respond_to?(:bytesize) ? string.bytesize : string.size
+        end
+
     end
   end
 end