Merge branch 'srandmember_count'

Conflicts:
	tests/TestRedis.php

Author: michael-grunder

README.markdown

@@ -2207,17 +2207,29 @@ $redis->sPop('key1'); /* 'member3', 'key1' => {'member2'} */
 -----
 _**Description**_: Returns a random element from the set value at Key, without removing it.
 ##### *Parameters*
-*key*
+*key*  
+*count* (Integer, optional)  
 ##### *Return value*
-*String* value from the set  
+If no count is provided, a random *String* value from the set will be returned.  If a count
+is provided, an array of values from the set will be returned.  Read about the different
+ways to use the count here: [SRANDMEMBER](http://redis.io/commands/srandmember)  
 *Bool* `FALSE` if set identified by key is empty or doesn't exist.
 ##### *Example*
 ~~~
 $redis->sAdd('key1' , 'member1');
 $redis->sAdd('key1' , 'member2');
 $redis->sAdd('key1' , 'member3'); /* 'key1' => {'member3', 'member1', 'member2'}*/
+
+// No count
 $redis->sRandMember('key1'); /* 'member1', 'key1' => {'member3', 'member1', 'member2'} */
 $redis->sRandMember('key1'); /* 'member3', 'key1' => {'member3', 'member1', 'member2'} */
+
+// With a count
+$redis->sRandMember('key1', 3); // Will return an array with all members from the set
+$redis->sRandMember('key1', 2); // Will an array with 2 members of the set
+$redis->sRandMember('key1', -100); // Will return an array of 100 elements, picked from our set (with dups)
+$redis->sRandMember('empty-set', 100); // Will return an empty array
+$redis->sRandMember('not-a-set', 100); // Will return FALSE
 ~~~
 
 ### sRem, sRemove

redis.c

@@ -2195,19 +2195,62 @@ PHP_METHOD(Redis, sPop)
 /* }}} */
 
 /* }}} */
-/* {{{ proto string Redis::sRandMember(string key)
+/* {{{ proto string Redis::sRandMember(string key [int count])
  */
 PHP_METHOD(Redis, sRandMember)
 {
-    generic_pop_function(INTERNAL_FUNCTION_PARAM_PASSTHRU, "SRANDMEMBER", 11);
+    zval *object;
+    RedisSock *redis_sock;
+    char *key = NULL, *cmd;
+    int key_len, cmd_len, key_free = 0;
+    long count;
+
+    // Parse our params
+    if(zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l",
+                                    &object, redis_ce, &key, &key_len, &count) == FAILURE) {
+        RETURN_FALSE;
+    }
+
+    // Get our redis socket
+    if(redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {
+        RETURN_FALSE;
+    }
+
+    // Prefix our key if necissary
+    key_free = redis_key_prefix(redis_sock, &key, &key_len TSRMLS_CC);
+
+    // If we have two arguments, we're running with an optional COUNT, which will return
+    // a multibulk reply.  Without the argument we'll return a string response
+    if(ZEND_NUM_ARGS() == 2) {
+        // Construct our command with count
+        cmd_len = redis_cmd_format_static(&cmd, "SRANDMEMBER", "sl", key, key_len, count);
+    } else {
+        // Construct our command
+        cmd_len = redis_cmd_format_static(&cmd, "SRANDMEMBER", "s", key, key_len);
+    }
+
+    // Free our key if we prefixed it
+    if(key_free) efree(key);
+
+    // Process our command
+    REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);
+
+    // Process our reply
+    IF_ATOMIC() {
+        // This will be bulk or multi-bulk depending if we passed the optional [COUNT] argument
+        if(redis_read_variant_reply(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL) < 0) {
+            RETURN_FALSE;
+        }
+    }
+    REDIS_PROCESS_RESPONSE(redis_read_variant_reply);
 }
 /* }}} */
 
 /* {{{ proto boolean Redis::sContains(string set, string value)
  */
 PHP_METHOD(Redis, sContains)
 {
-    zval *object;
+	zval *object;
     RedisSock *redis_sock;
     char *key = NULL, *val = NULL, *cmd;
     int key_len, val_len, cmd_len;

tests/TestRedis.php

@@ -1083,6 +1083,61 @@ public function testsRandMember() {
 	}
     }
 
+    public function testSRandMemberWithCount() {
+        // Make sure the set is nuked
+        $this->redis->delete('set0');
+        
+        // Run with a count (positive and negative) on an empty set
+        $ret_pos = $this->redis->sRandMember('set0', 10);
+        $ret_neg = $this->redis->sRandMember('set0', -10);
+        
+        // Should both be empty arrays
+        $this->assertTrue(is_array($ret_pos) && empty($ret_pos));
+        $this->assertTrue(is_array($ret_neg) && empty($ret_neg));
+
+        // Add a few items to the set
+        for($i=0;$i<100;$i++) {
+            $this->redis->sadd('set0', "member$i");
+        }
+
+        // Get less than the size of the list
+        $ret_slice = $this->redis->srandmember('set0', 20);
+
+        // Should be an array with 20 items
+        $this->assertTrue(is_array($ret_slice) && count($ret_slice) == 20);
+
+        // Ask for more items than are in the list (but with a positive count)
+        $ret_slice = $this->redis->srandmember('set0', 200);
+
+        // Should be an array, should be however big the set is, exactly
+        $this->assertTrue(is_array($ret_slice) && count($ret_slice) == $i);
+
+        // Now ask for too many items but negative
+        $ret_slice = $this->redis->srandmember('set0', -200);
+
+        // Should be an array, should have exactly the # of items we asked for (will be dups)
+        $this->assertTrue(is_array($ret_slice) && count($ret_slice) == 200);
+
+        //
+        // Test in a pipeline
+        //
+
+        $pipe = $this->redis->pipeline();
+
+        $pipe->srandmember('set0', 20);
+        $pipe->srandmember('set0', 200);
+        $pipe->srandmember('set0', -200);
+
+        $ret = $this->redis->exec();
+
+        $this->assertTrue(is_array($ret[0]) && count($ret[0]) == 20);
+        $this->assertTrue(is_array($ret[1]) && count($ret[1]) == $i);
+        $this->assertTrue(is_array($ret[2]) && count($ret[2]) == 200);
+
+        // Kill the set
+        $this->redis->del('set0');
+    }
+
     public function testsContains()
     {
         $this->redis->delete('set');
@@ -3263,8 +3318,10 @@ public function testUnserialize() {
     		1,1.5,'one',Array('this','is','an','array')
     	);
 
-        $serializers = Array(Redis::SERIALIZER_PHP);
-        if(defined('Redis::SERIALIZER_IGBINARY')) $serializers[] = Redis::SERIALIZER_IGBINARY;
+    	$serializers = Array(Redis::SERIALIZER_PHP);
+    	if(defined('Redis::SERIALIZER_IGBINARY')) {
+    		$serializers[] = Redis::SERIALIZER_IGBINARY;
+    	}
 
     	foreach($serializers as $mode) {
     		$vals_enc = Array();