Merge pull request #2 from scuml/sorted-set-floats

Adds double support sortedsets.  Adds withscores to ZRANGE

Author: scuml

Sources/SwiftRedis/Redis+SortedSet.swift

@@ -33,6 +33,10 @@ extension Redis {
     public func zadd(_ key: String, tuples: (Int, String)..., callback: (Int?, NSError?) -> Void) {
         zaddArrayOfScoreMembers(key, tuples: tuples, callback: callback)
     }
+    
+    public func zadd(_ key: String, tuples: (Double, String)..., callback: (Int?, NSError?) -> Void) {
+        zaddArrayOfScoreMembers(key, tuples: tuples, callback: callback)
+    }
 
     /// Add elements to a sorted set.
     ///
@@ -44,6 +48,10 @@ extension Redis {
     public func zadd(_ key: String, tuples: (Int, RedisString)..., callback: (Int?, NSError?) -> Void) {
         zaddArrayOfScoreMembers(key, tuples: tuples, callback: callback)
     }
+    
+    public func zadd(_ key: String, tuples: (Double, RedisString)..., callback: (Int?, NSError?) -> Void) {
+        zaddArrayOfScoreMembers(key, tuples: tuples, callback: callback)
+    }
 
     /// Add elements to a sorted set.
     ///
@@ -53,6 +61,10 @@ extension Redis {
     ///                      number of elements added to the sorted set.
     ///                      NSError will be non-nil if an error occurred.
     public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Int, String)], callback: (Int?, NSError?) -> Void) {
+        zaddArrayOfScoreMembers(key, tuples: tuples.map{(Double($0.0), $0.1)}, callback: callback)
+    }
+
+    public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Double, String)], callback: (Int?, NSError?) -> Void) {
         var command = ["ZADD"]
         command.append(key)
         for tuple in tuples {
@@ -72,6 +84,9 @@ extension Redis {
     ///                      number of elements added to the sorted set.
     ///                      NSError will be non-nil if an error occurred.
     public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Int, RedisString)], callback: (Int?, NSError?) -> Void) {
+        zaddArrayOfScoreMembers(key, tuples: tuples.map{(Double($0.0), $0.1)}, callback: callback)
+    }
+    public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Double, RedisString)], callback: (Int?, NSError?) -> Void) {
         var command = [RedisString("ZADD")]
         command.append(RedisString(key))
         for tuple in tuples {
@@ -239,12 +254,19 @@ extension Redis {
     /// - Parameter callback: The callback function, the Array<RedisString> will contain the
     ///                       elements fetched from the sorted set.
     ///                       NSError will be non-nil if an error occurred.
-    public func zrange(_ key: String, start: Int, stop: Int, callback: ([RedisString?]?, NSError?) -> Void) {
-        issueCommand("ZRANGE", key, String(start), String(stop)) { (response: RedisResponse) in
-            self.redisStringArrayResponseHandler(response, callback: callback)
+    public func zrange(_ key: String, start: Int, stop: Int, withscores: Bool = false, callback: ([RedisString?]?, NSError?) -> Void) {
+        if !withscores {
+            issueCommand("ZRANGE", key, String(start), String(stop)) { (response: RedisResponse) in
+                self.redisStringArrayResponseHandler(response, callback: callback)
+            }
+        } else {
+            issueCommand("ZRANGE", key, String(start), String(stop), "WITHSCORES") { (response: RedisResponse) in
+                self.redisStringArrayResponseHandler(response, callback: callback)
+            }
         }
     }
 
+
     /// Return a range of members in a sorted set, by lexicographical range.
     ///
     /// - Parameter key: The key.

Sources/SwiftRedis/RedisMulti+SortedSet.swift

@@ -29,6 +29,10 @@ extension RedisMulti {
     public func zadd(_ key: String, tuples: (Int, String)...) -> RedisMulti {
         return zaddArrayOfScoreMembers(key, tuples: tuples)
     }
+    @discardableResult
+    public func zadd(_ key: String, tuples: (Double, String)...) -> RedisMulti {
+        return zaddArrayOfScoreMembers(key, tuples: tuples)
+    }
 
     /// Add an ZADD command to the "transaction"
     ///
@@ -38,6 +42,10 @@ extension RedisMulti {
     /// - Returns: The `RedisMulti` object being added to.
     @discardableResult
     public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Int, String)]) -> RedisMulti {
+        return zaddArrayOfScoreMembers(key, tuples: tuples.map{(Double($0.0), $0.1)})
+    }
+    @discardableResult
+    public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Double, String)]) -> RedisMulti {
         var command = [RedisString("ZADD"), RedisString(key)]
         for tuple in tuples {
             command.append(RedisString(tuple.0))
@@ -57,6 +65,10 @@ extension RedisMulti {
     public func zadd(_ key: String, tuples: (Int, RedisString)...) -> RedisMulti {
         return zaddArrayOfScoreMembers(key, tuples: tuples)
     }
+    @discardableResult
+    public func zadd(_ key: String, tuples: (Double, RedisString)...) -> RedisMulti {
+        return zaddArrayOfScoreMembers(key, tuples: tuples)
+    }
 
     /// Add an ZADD command to the "transaction"
     ///
@@ -66,6 +78,10 @@ extension RedisMulti {
     /// - Returns: The `RedisMulti` object being added to.
     @discardableResult
     public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Int, RedisString)]) -> RedisMulti {
+        return zaddArrayOfScoreMembers(key, tuples: tuples.map{(Double($0.0), $0.1)})
+    }
+    @discardableResult
+    public func zaddArrayOfScoreMembers(_ key: String, tuples: [(Double, RedisString)]) -> RedisMulti {
         var command = [RedisString("ZADD"), RedisString(key)]
         for tuple in tuples {
             command.append(RedisString(tuple.0))

Tests/SwiftRedisTests/TestSetCommands.swift

@@ -23,6 +23,7 @@ public class TestSetCommands: XCTestCase {
     static var allTests: [(String, (TestSetCommands) -> () throws -> Void)] {
         return [
             ("test_ZAdd", test_ZAdd),
+            ("test_ZAddFloat", test_ZAddFloat),
             ("test_ZCard", test_ZCard),
             ("test_ZCount", test_ZCount),
             ("test_ZIncrby", test_ZIncrby),
@@ -92,6 +93,39 @@ public class TestSetCommands: XCTestCase {
         waitForExpectations(timeout: 5, handler: { error in XCTAssertNil(error, "Timeout") })
     }
 
+    func test_ZAddFloat() {
+        let expectation1 = expectation(description: "Add score(s) and member(s) to the set")
+
+        setupTests {
+            redis.zadd(self.key1, tuples: (-1.5, "one"), (2.33333333, "two"), (3.14159, "three")) {
+                (result: Int?, error: NSError?) in
+
+                XCTAssertNil(error)
+                XCTAssertNotNil(result)
+
+                redis.zrange(self.key1, start: 0, stop: 2, withscores: true, callback: {
+                    (resultList: [RedisString?]?, zRangeError: NSError?) in
+
+                    XCTAssertNil(zRangeError)
+
+                    XCTAssertEqual(resultList?[0], RedisString("one"), "The first element of the list should be \(RedisString("one")). It was \(String(describing: resultList?[0]))")
+                    XCTAssertEqual(resultList?[1], RedisString("-1.5"), "The first score of the list should be  \(RedisString("-1.5")). It was \(String(describing: resultList?[0]))")
+
+                    XCTAssertEqual(resultList?[2], RedisString("two"), "The first element of the list should be \(RedisString("two")). It was \(String(describing: resultList?[1]))")
+                    XCTAssertEqual(resultList?[3], RedisString("2.33333333"), "The first score of the list should be \(RedisString("2.33333333")). It was \(String(describing: resultList?[1]))")
+
+                    XCTAssertEqual(resultList?[4], RedisString("three"), "The first element of the list should be \(RedisString("three")). It was \(String(describing: resultList?[2]))")
+                    XCTAssertEqual(resultList?[5], RedisString("3.14159"), "The first score of the list should be \(RedisString("3.14159")). It was \(String(describing: resultList?[2]))")
+
+                    XCTAssertEqual(resultList?.count, 6, "The size of the list should be 6. It was \(String(describing: resultList?.count))")
+                    expectation1.fulfill()
+                })
+
+            }
+        }
+        waitForExpectations(timeout: 5, handler: { error in XCTAssertNil(error, "Timeout") })
+    }
+
     func test_ZCard() {
         let expectation1 = expectation(description: "Returns the sorted set cardinality of the sorted set ")
         setupTests {