redis 2.2.0 → 2.2.1

data/CHANGELOG.md

@@ -1,4 +1,19 @@
-# 2.2.0 (unreleased)
+# 2.2.2 (unreleased)
+
+# 2.2.1
+
+* Internal API: Client#call and family are now called with a single array
+  argument, since splatting a large number of arguments (100K+) results in a
+  stack overflow on 1.9.2.
+
+* The `INFO` command can optionally take a subcommand. When the subcommand is
+  `COMMANDSTATS`, the client will properly format the returned statistics per
+  command. Subcommands for `INFO` are available since Redis v2.3.0 (unstable).
+
+* Change `IO#syswrite` back to the buffered `IO#write` since some Rubies do
+  short writes for large (1MB+) buffers and some don't (see issue #108).
+
+# 2.2.0
 
 * Added method `Redis#without_reconnect` that ensures the client will not try
   to reconnect when running the code inside the specified block.

data/README.md

@@ -185,6 +185,24 @@ This library (v2.2) is tested against the following interpreters:
 
 Check the [Redis Command Reference](http://redis.io/commands) or check the tests to find out how to use this client.
 
+## Contributors
+
+(ordered chronologically with more than 5 commits, see `git shortlog -sn` for
+all contributors)
+
+* Ezra Zygmuntowicz
+* Taylor Weibley
+* Matthew Clark
+* Brian McKinney
+* Luca Guidi
+* Salvatore Sanfillipo
+* Chris Wanstrath
+* Damian Janowski
+* Michel Martens
+* Nick Quaranto
+* Pieter Noordhuis
+* Ilya Grigorik
+
 ## Contributing
 
 [Fork the project](http://github.com/ezmobius/redis-rb) and send pull requests. You can also ask for help at `#redis-rb` on Freenode.

data/Rakefile

@@ -65,7 +65,7 @@ namespace :test do
         puts "Running tests against hiredis v#{Hiredis::VERSION}"
 
         Cutest.run(Dir["./test/**/*_test.rb"])
-      rescue
+      rescue LoadError
         puts "Skipping tests against hiredis"
       end
     end
@@ -87,9 +87,7 @@ namespace :test do
 
         threaded_tests = ['./test/thread_safety_test.rb']
         Cutest.run(Dir['./test/**/*_test.rb'] - threaded_tests)
-      rescue Exception => e
-        puts e
-        puts e.backtrace.join("\n")
+      rescue LoadError
         puts "Skipping tests against em-synchrony"
       end
     end
@@ -189,7 +187,7 @@ namespace :doc do
   end
 
   task :deploy do
-    system "rsync --del -avz doc/* redis-rb.keyvalue.org:deploys/redis-rb.keyvalue.org/"
+    system "rsync --del -avz doc/ redis-rb.keyvalue.org:deploys/redis-rb.keyvalue.org/"
   end
 end
 

data/TODO.md

@@ -0,0 +1,4 @@
+# 2.3
+
+* Remove the splat from the prototypes of `Client#call`, `Client#call_loop`,
+  `Pipeline#call` and `Subscription#call`.

data/lib/redis.rb

@@ -72,7 +72,7 @@ class Redis
   # Authenticate to the server.
   def auth(password)
     synchronize do
-      @client.call(:auth, password)
+      @client.call [:auth, password]
     end
   end
 
@@ -80,26 +80,33 @@ class Redis
   def select(db)
     synchronize do
       @client.db = db
-      @client.call(:select, db)
+      @client.call [:select, db]
     end
   end
 
   # Get information and statistics about the server.
-  def info
+  def info(cmd = nil)
     synchronize do
-      reply = @client.call(:info)
+      reply = @client.call [:info, cmd].compact
 
       if reply.kind_of?(String)
-        Hash[*reply.split(/:|\r\n/).grep(/^[^#]/)]
-      else
-        reply
+        reply = Hash[*reply.split(/:|\r\n/).grep(/^[^#]/)]
+
+        if cmd && cmd.to_s == "commandstats"
+          # Extract nested hashes for INFO COMMANDSTATS
+          reply = Hash[reply.map do |k, v|
+            [k[/^cmdstat_(.*)$/, 1], Hash[*v.split(/,|=/)]]
+          end]
+        end
       end
+
+      reply
     end
   end
 
   def config(action, *args)
     synchronize do
-      reply = @client.call(:config, action, *args)
+      reply = @client.call [:config, action, *args]
 
       if reply.kind_of?(Array) && action == :get
         Hash[*reply]
@@ -112,97 +119,97 @@ class Redis
   # Remove all keys from the current database.
   def flushdb
     synchronize do
-      @client.call(:flushdb)
+      @client.call [:flushdb]
     end
   end
 
   # Remove all keys from all databases.
   def flushall
     synchronize do
-      @client.call(:flushall)
+      @client.call [:flushall]
     end
   end
 
   # Synchronously save the dataset to disk.
   def save
     synchronize do
-      @client.call(:save)
+      @client.call [:save]
     end
   end
 
   # Asynchronously save the dataset to disk.
   def bgsave
     synchronize do
-      @client.call(:bgsave)
+      @client.call [:bgsave]
     end
   end
 
   # Asynchronously rewrite the append-only file.
   def bgrewriteaof
     synchronize do
-      @client.call(:bgrewriteaof)
+      @client.call [:bgrewriteaof]
     end
   end
 
   # Get the value of a key.
   def get(key)
     synchronize do
-      @client.call(:get, key)
+      @client.call [:get, key]
     end
   end
 
   # Returns the bit value at offset in the string value stored at key.
   def getbit(key, offset)
     synchronize do
-      @client.call(:getbit, key, offset)
+      @client.call [:getbit, key, offset]
     end
   end
 
   # Get a substring of the string stored at a key.
   def getrange(key, start, stop)
     synchronize do
-      @client.call(:getrange, key, start, stop)
+      @client.call [:getrange, key, start, stop]
     end
   end
 
   # Set the string value of a key and return its old value.
   def getset(key, value)
     synchronize do
-      @client.call(:getset, key, value)
+      @client.call [:getset, key, value]
     end
   end
 
   # Get the values of all the given keys.
   def mget(*keys)
     synchronize do
-      @client.call(:mget, *keys)
+      @client.call [:mget, *keys]
     end
   end
 
   # Append a value to a key.
   def append(key, value)
     synchronize do
-      @client.call(:append, key, value)
+      @client.call [:append, key, value]
     end
   end
 
   def substr(key, start, stop)
     synchronize do
-      @client.call(:substr, key, start, stop)
+      @client.call [:substr, key, start, stop]
     end
   end
 
   # Get the length of the value stored in a key.
   def strlen(key)
     synchronize do
-      @client.call(:strlen, key)
+      @client.call [:strlen, key]
     end
   end
 
   # Get all the fields and values in a hash.
   def hgetall(key)
     synchronize do
-      reply = @client.call(:hgetall, key)
+      reply = @client.call [:hgetall, key]
 
       if reply.kind_of?(Array)
         Hash[*reply]
@@ -215,28 +222,28 @@ class Redis
   # Get the value of a hash field.
   def hget(key, field)
     synchronize do
-      @client.call(:hget, key, field)
+      @client.call [:hget, key, field]
     end
   end
 
   # Delete a hash field.
   def hdel(key, field)
     synchronize do
-      @client.call(:hdel, key, field)
+      @client.call [:hdel, key, field]
     end
   end
 
   # Get all the fields in a hash.
   def hkeys(key)
     synchronize do
-      @client.call(:hkeys, key)
+      @client.call [:hkeys, key]
     end
   end
 
   # Find all keys matching the given pattern.
   def keys(pattern = "*")
     synchronize do
-      reply = @client.call(:keys, pattern)
+      reply = @client.call [:keys, pattern]
 
       if reply.kind_of?(String)
         reply.split(" ")
@@ -249,126 +256,126 @@ class Redis
   # Return a random key from the keyspace.
   def randomkey
     synchronize do
-      @client.call(:randomkey)
+      @client.call [:randomkey]
     end
   end
 
   # Echo the given string.
   def echo(value)
     synchronize do
-      @client.call(:echo, value)
+      @client.call [:echo, value]
     end
   end
 
   # Ping the server.
   def ping
     synchronize do
-      @client.call(:ping)
+      @client.call [:ping]
     end
   end
 
   # Get the UNIX time stamp of the last successful save to disk.
   def lastsave
     synchronize do
-      @client.call(:lastsave)
+      @client.call [:lastsave]
     end
   end
 
   # Return the number of keys in the selected database.
   def dbsize
     synchronize do
-      @client.call(:dbsize)
+      @client.call [:dbsize]
     end
   end
 
   # Determine if a key exists.
   def exists(key)
     synchronize do
-      _bool @client.call(:exists, key)
+      _bool @client.call [:exists, key]
     end
   end
 
   # Get the length of a list.
   def llen(key)
     synchronize do
-      @client.call(:llen, key)
+      @client.call [:llen, key]
     end
   end
 
   # Get a range of elements from a list.
   def lrange(key, start, stop)
     synchronize do
-      @client.call(:lrange, key, start, stop)
+      @client.call [:lrange, key, start, stop]
     end
   end
 
   # Trim a list to the specified range.
   def ltrim(key, start, stop)
     synchronize do
-      @client.call(:ltrim, key, start, stop)
+      @client.call [:ltrim, key, start, stop]
     end
   end
 
   # Get an element from a list by its index.
   def lindex(key, index)
     synchronize do
-      @client.call(:lindex, key, index)
+      @client.call [:lindex, key, index]
     end
   end
 
   # Insert an element before or after another element in a list.
   def linsert(key, where, pivot, value)
     synchronize do
-      @client.call(:linsert, key, where, pivot, value)
+      @client.call [:linsert, key, where, pivot, value]
     end
   end
 
   # Set the value of an element in a list by its index.
   def lset(key, index, value)
     synchronize do
-      @client.call(:lset, key, index, value)
+      @client.call [:lset, key, index, value]
     end
   end
 
   # Remove elements from a list.
   def lrem(key, count, value)
     synchronize do
-      @client.call(:lrem, key, count, value)
+      @client.call [:lrem, key, count, value]
     end
   end
 
   # Append a value to a list.
   def rpush(key, value)
     synchronize do
-      @client.call(:rpush, key, value)
+      @client.call [:rpush, key, value]
     end
   end
 
   # Append a value to a list, only if the list exists.
   def rpushx(key, value)
     synchronize do
-      @client.call(:rpushx, key, value)
+      @client.call [:rpushx, key, value]
     end
   end
 
   # Prepend a value to a list.
   def lpush(key, value)
     synchronize do
-      @client.call(:lpush, key, value)
+      @client.call [:lpush, key, value]
     end
   end
 
   # Prepend a value to a list, only if the list exists.
   def lpushx(key, value)
     synchronize do
-      @client.call(:lpushx, key, value)
+      @client.call [:lpushx, key, value]
     end
   end
 
   # Remove and get the last element in a list.
   def rpop(key)
     synchronize do
-      @client.call(:rpop, key)
+      @client.call [:rpop, key]
     end
   end
 
@@ -397,126 +404,126 @@ class Redis
   # Remove the last element in a list, append it to another list and return it.
   def rpoplpush(source, destination)
     synchronize do
-      @client.call(:rpoplpush, source, destination)
+      @client.call [:rpoplpush, source, destination]
     end
   end
 
   # Remove and get the first element in a list.
   def lpop(key)
     synchronize do
-      @client.call(:lpop, key)
+      @client.call [:lpop, key]
     end
   end
 
   # Get all the members in a set.
   def smembers(key)
     synchronize do
-      @client.call(:smembers, key)
+      @client.call [:smembers, key]
     end
   end
 
   # Determine if a given value is a member of a set.
   def sismember(key, member)
     synchronize do
-      _bool @client.call(:sismember, key, member)
+      _bool @client.call [:sismember, key, member]
     end
   end
 
   # Add a member to a set.
   def sadd(key, value)
     synchronize do
-      _bool @client.call(:sadd, key, value)
+      _bool @client.call [:sadd, key, value]
     end
   end
 
   # Remove a member from a set.
   def srem(key, value)
     synchronize do
-      _bool @client.call(:srem, key, value)
+      _bool @client.call [:srem, key, value]
     end
   end
 
   # Move a member from one set to another.
   def smove(source, destination, member)
     synchronize do
-      _bool @client.call(:smove, source, destination, member)
+      _bool @client.call [:smove, source, destination, member]
     end
   end
 
   # Remove and return a random member from a set.
   def spop(key)
     synchronize do
-      @client.call(:spop, key)
+      @client.call [:spop, key]
     end
   end
 
   # Get the number of members in a set.
   def scard(key)
     synchronize do
-      @client.call(:scard, key)
+      @client.call [:scard, key]
     end
   end
 
   # Intersect multiple sets.
   def sinter(*keys)
     synchronize do
-      @client.call(:sinter, *keys)
+      @client.call [:sinter, *keys]
     end
   end
 
   # Intersect multiple sets and store the resulting set in a key.
   def sinterstore(destination, *keys)
     synchronize do
-      @client.call(:sinterstore, destination, *keys)
+      @client.call [:sinterstore, destination, *keys]
     end
   end
 
   # Add multiple sets.
   def sunion(*keys)
     synchronize do
-      @client.call(:sunion, *keys)
+      @client.call [:sunion, *keys]
     end
   end
 
   # Add multiple sets and store the resulting set in a key.
   def sunionstore(destination, *keys)
     synchronize do
-      @client.call(:sunionstore, destination, *keys)
+      @client.call [:sunionstore, destination, *keys]
     end
   end
 
   # Subtract multiple sets.
   def sdiff(*keys)
     synchronize do
-      @client.call(:sdiff, *keys)
+      @client.call [:sdiff, *keys]
     end
   end
 
   # Subtract multiple sets and store the resulting set in a key.
   def sdiffstore(destination, *keys)
     synchronize do
-      @client.call(:sdiffstore, destination, *keys)
+      @client.call [:sdiffstore, destination, *keys]
     end
   end
 
   # Get a random member from a set.
   def srandmember(key)
     synchronize do
-      @client.call(:srandmember, key)
+      @client.call [:srandmember, key]
     end
   end
 
   # Add a member to a sorted set, or update its score if it already exists.
   def zadd(key, score, member)
     synchronize do
-      _bool @client.call(:zadd, key, score, member)
+      _bool @client.call [:zadd, key, score, member]
     end
   end
 
   # Determine the index of a member in a sorted set.
   def zrank(key, member)
     synchronize do
-      @client.call(:zrank, key, member)
+      @client.call [:zrank, key, member]
     end
   end
 
@@ -524,21 +531,21 @@ class Redis
   # high to low.
   def zrevrank(key, member)
     synchronize do
-      @client.call(:zrevrank, key, member)
+      @client.call [:zrevrank, key, member]
     end
   end
 
   # Increment the score of a member in a sorted set.
   def zincrby(key, increment, member)
     synchronize do
-      @client.call(:zincrby, key, increment, member)
+      @client.call [:zincrby, key, increment, member]
     end
   end
 
   # Get the number of members in a sorted set.
   def zcard(key)
     synchronize do
-      @client.call(:zcard, key)
+      @client.call [:zcard, key]
     end
   end
 
@@ -550,7 +557,7 @@ class Redis
     end
 
     synchronize do
-      @client.call(:zrange, key, start, stop, *command.to_a)
+      @client.call [:zrange, key, start, stop, *command.to_a]
     end
   end
 
@@ -563,14 +570,14 @@ class Redis
     end
 
     synchronize do
-      @client.call(:zrangebyscore, key, min, max, *command.to_a)
+      @client.call [:zrangebyscore, key, min, max, *command.to_a]
     end
   end
 
   # Count the members in a sorted set with scores within the given values.
   def zcount(key, start, stop)
     synchronize do
-      @client.call(:zcount, key, start, stop)
+      @client.call [:zcount, key, start, stop]
     end
   end
 
@@ -583,7 +590,7 @@ class Redis
     end
 
     synchronize do
-      @client.call(:zrevrange, key, start, stop, *command.to_a)
+      @client.call [:zrevrange, key, start, stop, *command.to_a]
     end
   end
 
@@ -597,35 +604,35 @@ class Redis
     end
 
     synchronize do
-      @client.call(:zrevrangebyscore, key, max, min, *command.to_a)
+      @client.call [:zrevrangebyscore, key, max, min, *command.to_a]
     end
   end
 
   # Remove all members in a sorted set within the given scores.
   def zremrangebyscore(key, min, max)
     synchronize do
-      @client.call(:zremrangebyscore, key, min, max)
+      @client.call [:zremrangebyscore, key, min, max]
     end
   end
 
   # Remove all members in a sorted set within the given indexes.
   def zremrangebyrank(key, start, stop)
     synchronize do
-      @client.call(:zremrangebyrank, key, start, stop)
+      @client.call [:zremrangebyrank, key, start, stop]
     end
   end
 
   # Get the score associated with the given member in a sorted set.
   def zscore(key, member)
     synchronize do
-      @client.call(:zscore, key, member)
+      @client.call [:zscore, key, member]
     end
   end
 
   # Remove a member from a sorted set.
   def zrem(key, member)
     synchronize do
-      _bool @client.call(:zrem, key, member)
+      _bool @client.call [:zrem, key, member]
     end
   end
 
@@ -638,7 +645,7 @@ class Redis
     end
 
     synchronize do
-      @client.call(:zinterstore, destination, keys.size, *(keys + command.to_a))
+      @client.call [:zinterstore, destination, keys.size, *(keys + command.to_a)]
     end
   end
 
@@ -650,91 +657,91 @@ class Redis
     end
 
     synchronize do
-      @client.call(:zunionstore, destination, keys.size, *(keys + command.to_a))
+      @client.call [:zunionstore, destination, keys.size, *(keys + command.to_a)]
     end
   end
 
   # Move a key to another database.
   def move(key, db)
     synchronize do
-      _bool @client.call(:move, key, db)
+      _bool @client.call [:move, key, db]
     end
   end
 
   # Set the value of a key, only if the key does not exist.
   def setnx(key, value)
     synchronize do
-      _bool @client.call(:setnx, key, value)
+      _bool @client.call [:setnx, key, value]
     end
   end
 
   # Delete a key.
   def del(*keys)
     synchronize do
-      @client.call(:del, *keys)
+      @client.call [:del, *keys]
     end
   end
 
   # Rename a key.
   def rename(old_name, new_name)
     synchronize do
-      @client.call(:rename, old_name, new_name)
+      @client.call [:rename, old_name, new_name]
     end
   end
 
   # Rename a key, only if the new key does not exist.
   def renamenx(old_name, new_name)
     synchronize do
-      _bool @client.call(:renamenx, old_name, new_name)
+      _bool @client.call [:renamenx, old_name, new_name]
     end
   end
 
   # Set a key's time to live in seconds.
   def expire(key, seconds)
     synchronize do
-      _bool @client.call(:expire, key, seconds)
+      _bool @client.call [:expire, key, seconds]
     end
   end
 
   # Remove the expiration from a key.
   def persist(key)
     synchronize do
-      _bool @client.call(:persist, key)
+      _bool @client.call [:persist, key]
     end
   end
 
   # Get the time to live for a key.
   def ttl(key)
     synchronize do
-      @client.call(:ttl, key)
+      @client.call [:ttl, key]
     end
   end
 
   # Set the expiration for a key as a UNIX timestamp.
   def expireat(key, unix_time)
     synchronize do
-      _bool @client.call(:expireat, key, unix_time)
+      _bool @client.call [:expireat, key, unix_time]
     end
   end
 
   # Set the string value of a hash field.
   def hset(key, field, value)
     synchronize do
-      _bool @client.call(:hset, key, field, value)
+      _bool @client.call [:hset, key, field, value]
     end
   end
 
   # Set the value of a hash field, only if the field does not exist.
   def hsetnx(key, field, value)
     synchronize do
-      _bool @client.call(:hsetnx, key, field, value)
+      _bool @client.call [:hsetnx, key, field, value]
     end
   end
 
   # Set multiple hash fields to multiple values.
   def hmset(key, *attrs)
     synchronize do
-      @client.call(:hmset, key, *attrs)
+      @client.call [:hmset, key, *attrs]
     end
   end
 
@@ -745,7 +752,7 @@ class Redis
   # Get the values of all the given hash fields.
   def hmget(key, *fields)
     synchronize do
-      @client.call(:hmget, key, *fields)
+      @client.call [:hmget, key, *fields]
     end
   end
 
@@ -762,55 +769,61 @@ class Redis
   # Get the number of fields in a hash.
   def hlen(key)
     synchronize do
-      @client.call(:hlen, key)
+      @client.call [:hlen, key]
     end
   end
 
   # Get all the values in a hash.
   def hvals(key)
     synchronize do
-      @client.call(:hvals, key)
+      @client.call [:hvals, key]
     end
   end
 
   # Increment the integer value of a hash field by the given number.
   def hincrby(key, field, increment)
     synchronize do
-      @client.call(:hincrby, key, field, increment)
+      @client.call [:hincrby, key, field, increment]
     end
   end
 
   # Discard all commands issued after MULTI.
   def discard
     synchronize do
-      @client.call(:discard)
+      @client.call [:discard]
     end
   end
 
   # Determine if a hash field exists.
   def hexists(key, field)
     synchronize do
-      _bool @client.call(:hexists, key, field)
+      _bool @client.call [:hexists, key, field]
     end
   end
 
   # Listen for all requests received by the server in real time.
   def monitor(&block)
     synchronize do
-      @client.call_loop(:monitor, &block)
+      @client.call_loop([:monitor], &block)
     end
   end
 
   def debug(*args)
     synchronize do
-      @client.call(:debug, *args)
+      @client.call [:debug, *args]
+    end
+  end
+
+  def object(*args)
+    synchronize do
+      @client.call [:object, *args]
     end
   end
 
   # Internal command used for replication.
   def sync
     synchronize do
-      @client.call(:sync)
+      @client.call [:sync]
     end
   end
 
@@ -825,35 +838,35 @@ class Redis
   # Set the string value of a key.
   def set(key, value)
     synchronize do
-      @client.call(:set, key, value)
+      @client.call [:set, key, value]
     end
   end
 
   # Sets or clears the bit at offset in the string value stored at key.
   def setbit(key, offset, value)
     synchronize do
-      @client.call(:setbit, key, offset, value)
+      @client.call [:setbit, key, offset, value]
     end
   end
 
   # Set the value and expiration of a key.
   def setex(key, ttl, value)
     synchronize do
-      @client.call(:setex, key, ttl, value)
+      @client.call [:setex, key, ttl, value]
     end
   end
 
   # Overwrite part of a string at key starting at the specified offset.
   def setrange(key, offset, value)
     synchronize do
-      @client.call(:setrange, key, offset, value)
+      @client.call [:setrange, key, offset, value]
     end
   end
 
   # Set multiple keys to multiple values.
   def mset(*args)
     synchronize do
-      @client.call(:mset, *args)
+      @client.call [:mset, *args]
     end
   end
 
@@ -864,7 +877,7 @@ class Redis
   # Set multiple keys to multiple values, only if none of the keys exist.
   def msetnx(*args)
     synchronize do
-      @client.call(:msetnx, *args)
+      @client.call [:msetnx, *args]
     end
   end
 
@@ -893,42 +906,42 @@ class Redis
     end
 
     synchronize do
-      @client.call(:sort, key, *command.to_a)
+      @client.call [:sort, key, *command.to_a]
     end
   end
 
   # Increment the integer value of a key by one.
   def incr(key)
     synchronize do
-      @client.call(:incr, key)
+      @client.call [:incr, key]
     end
   end
 
   # Increment the integer value of a key by the given number.
   def incrby(key, increment)
     synchronize do
-      @client.call(:incrby, key, increment)
+      @client.call [:incrby, key, increment]
     end
   end
 
   # Decrement the integer value of a key by one.
   def decr(key)
     synchronize do
-      @client.call(:decr, key)
+      @client.call [:decr, key]
     end
   end
 
   # Decrement the integer value of a key by the given number.
   def decrby(key, decrement)
     synchronize do
-      @client.call(:decrby, key, decrement)
+      @client.call [:decrby, key, decrement]
     end
   end
 
   # Determine the type stored at key.
   def type(key)
     synchronize do
-      @client.call(:type, key)
+      @client.call [:type, key]
     end
   end
 
@@ -936,7 +949,7 @@ class Redis
   def quit
     synchronize do
       begin
-        @client.call(:quit)
+        @client.call [:quit]
       rescue Errno::ECONNRESET
       ensure
         @client.disconnect
@@ -947,14 +960,14 @@ class Redis
   # Synchronously save the dataset to disk and then shut down the server.
   def shutdown
     synchronize do
-      @client.call(:shutdown)
+      @client.call_without_reply [:shutdown]
     end
   end
 
   # Make the server a slave of another instance, or promote it as master.
   def slaveof(host, port)
     synchronize do
-      @client.call(:slaveof, host, port)
+      @client.call [:slaveof, host, port]
     end
   end
 
@@ -973,21 +986,21 @@ class Redis
   # Watch the given keys to determine execution of the MULTI/EXEC block.
   def watch(*keys)
     synchronize do
-      @client.call(:watch, *keys)
+      @client.call [:watch, *keys]
     end
   end
 
   # Forget about all watched keys.
   def unwatch
     synchronize do
-      @client.call(:unwatch)
+      @client.call [:unwatch]
     end
   end
 
   # Execute all commands issued after MULTI.
   def exec
     synchronize do
-      @client.call(:exec)
+      @client.call [:exec]
     end
   end
 
@@ -1011,7 +1024,7 @@ class Redis
   # Post a message to a channel.
   def publish(channel, message)
     synchronize do
-      @client.call(:publish, channel, message)
+      @client.call [:publish, channel, message]
     end
   end
 
@@ -1065,7 +1078,7 @@ class Redis
 
   def method_missing(command, *args)
     synchronize do
-      @client.call(command, *args)
+      @client.call [command, *args]
     end
   end
 
@@ -1107,12 +1120,15 @@ class Redis
 
 private
 
+  # Commands returning 1 for true and 0 for false may be executed in a pipeline
+  # where the method call will return nil. Propagate the nil instead of falsely
+  # returning false.
   def _bool(value)
-    value == 1
+    value == 1 if value
   end
 
   def subscription(method, channels, block)
-    return @client.call(method, *channels) if subscribed?
+    return @client.call [method, *channels] if subscribed?
 
     begin
       original, @client = @client, SubscribedClient.new(@client)