Add basic non-NIO wrappers for Redis

Author: Mordil

Package.swift

@@ -6,14 +6,14 @@ let package = Package(
     name: "Redis",
     products: [
         .library(name: "NIORedis", targets: ["NIORedis"]),
-        //.library(name: "Redis", targets: [""])
+        .library(name: "Redis", targets: ["Redis"])
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-nio.git", .branch("master"))
     ],
     targets: [
         .target(name: "NIORedis", dependencies: ["NIO"]),
-        //.target(name: "Redis", dependencies: ["NIORedis"]),
+        .target(name: "Redis", dependencies: ["NIORedis"]),
         .testTarget(name: "NIORedisTests", dependencies: ["NIORedis", "NIO"]),
         //.testTarget(name: "RedisTests", dependencies: ["Redis"])
     ]

Sources/NIORedis/Exported.swift

@@ -0,0 +1 @@
+@_exported import NIO

Sources/Redis/Redis.swift

@@ -0,0 +1,35 @@
+import Foundation
+import NIO
+import NIORedis
+
+/// A factory that handles all necessary details for creating `RedisConnection` instances.
+public final class Redis {
+    private let driver: NIORedis
+
+    deinit { try? driver.terminate() }
+
+    public init(threadCount: Int = 1) {
+        self.driver = NIORedis(executionModel: .spawnThreads(threadCount))
+    }
+
+    public func makeConnection(
+        hostname: String = "localhost",
+        port: Int = 6379,
+        password: String? = nil,
+        queue: DispatchQueue = .main,
+        _ callback: @escaping (Result<RedisConnection, Error>) -> Void
+    ) {
+        driver.makeConnection(hostname: hostname, port: port, password: password)
+            .map {
+                let connection = RedisConnection(driver: $0, callbackQueue: queue)
+                queue.async {
+                    callback(.success(connection))
+                }
+            }
+            .whenFailure { error in
+                queue.async {
+                    callback(.failure(error))
+                }
+            }
+    }
+}

Sources/Redis/RedisConnection.swift

@@ -0,0 +1,28 @@
+import Foundation
+import NIORedis
+
+public final class RedisConnection {
+    private let driverConnection: NIORedisConnection
+    private let queue: DispatchQueue
+
+    init(driver: NIORedisConnection, callbackQueue: DispatchQueue) {
+        self.driverConnection = driver
+        self.queue = callbackQueue
+    }
+
+    public func get(
+        _ key: String,
+        queue: DispatchQueue = .main,
+        _ callback: @escaping (Result<String?, Error>
+    ) -> Void) {
+        // TODO: Make this a generic method to avoid copy/paste
+        driverConnection.get(key)
+            .map { result in
+                queue.async { callback(.success(result)) }
+            }
+            .whenFailure { error in
+                queue.async { callback(.failure(error)) }
+            }
+    }
+}
+