Rename usage of RedisData to RESPValue or just RESP where it makes sense

Author: Mordil

README.md

@@ -79,7 +79,7 @@ print(result) // Optional("some value")
 
 // raw commands
 
-let keyCount = try connection.command("DEL", [RedisData(bulk: "my_key")])
+let keyCount = try connection.command("DEL", [RESPValue(bulk: "my_key")])
     .thenThrowing { res in
         guard case let .integer(count) else {
             // throw Error
@@ -95,12 +95,12 @@ try redis.terminate()
 try elg.syncShutdownGracefully()
 ```
 
-### RedisData & RedisDataConvertible
+### RESPValue & RESPValueConvertible
 This is a 1:1 mapping enum of the `RESP` types: `Simple String`, `Bulk String`, `Array`, `Integer` and `Error`.
 
-Conforming to `RedisDataConvertible` allows Swift types to more easily convert between `RedisData` and native types.
+Conforming to `RESPValueConvertible` allows Swift types to more easily convert between `RESPValue` and native types.
 
-`Array`, `Data`, `Float`, `Double`, `FixedWidthInteger`, `String`, and of course `RedisData` all conform in this package.
+`Array`, `Data`, `Float`, `Double`, `FixedWidthInteger`, `String`, and of course `RESPValue` all conform in this package.
 
 A `ByteToMessageDecoder` and `MessageToByteEncoder` are used for the conversion process on connections.
 
@@ -110,10 +110,10 @@ This class uses a `ChannelInboundHandler` that handles the actual process of sen
 While it does handle a queue of messages, so as to not be blocking, pipelining is implemented with `NIORedisPipeline`.
 
 ### NIORedisPipeline
-A `NIORedisPipeline` is a quick abstraction that buffers an array of complete messages as `RedisData`, and executing them in sequence after a
+A `NIORedisPipeline` is a quick abstraction that buffers an array of complete messages as `RESPValue`, and executing them in sequence after a
 user has invoked `execute()`.
 
-It returns an `EventLoopFuture<[RedisData]>` with the results of all commands executed - unless one errors.
+It returns an `EventLoopFuture<[RESPValue]>` with the results of all commands executed - unless one errors.
 
 ## Redis
 

Sources/DispatchRedis/RedisPipeline.swift

@@ -32,15 +32,15 @@ public final class RedisPipeline {
     ///     - arguments: The arguments, if any, to send with the command.
     /// - Returns: A self-reference to this `RedisPipeline` instance for chaining commands.
     @discardableResult
-    public func enqueue(command: String, arguments: [RedisDataConvertible] = []) throws -> RedisPipeline {
+    public func enqueue(command: String, arguments: [RESPConvertible] = []) throws -> RedisPipeline {
         try _driverPipeline.enqueue(command: command, arguments: arguments)
         return self
     }
 
     /// Flushes the queue, sending all of the commands to Redis in the same order as they were enqueued.
     /// - Important: If any of the commands fail, the remaining commands will not execute and the callback will receive a failure.
     /// - Parameter callback: The callback to receive the results of the pipeline of commands, or an error if thrown.
-    public func execute(_ callback: @escaping (Result<[RedisData], Error>) -> Void) {
+    public func execute(_ callback: @escaping (Result<[RESPValue], Error>) -> Void) {
         _driverPipeline.execute()
             .map { results in
                 self.queue.async { callback(.success(results)) }

Sources/NIORedis/Coders/RedisDataDecoder.swift renamed to Sources/NIORedis/ChannelHandlers/RESPDecoder.swift

@@ -4,9 +4,9 @@ import NIO
 /// Handles incoming byte messages from Redis and decodes them according to the RESP protocol.
 ///
 /// See: https://redis.io/topics/protocol
-internal final class RedisDataDecoder: ByteToMessageDecoder {
+internal final class RESPDecoder: ByteToMessageDecoder {
     /// `ByteToMessageDecoder`
-    public typealias InboundOut = RedisData
+    public typealias InboundOut = RESPValue
 
     /// See `ByteToMessageDecoder.decode(ctx:buffer:)`
     func decode(ctx: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
@@ -16,8 +16,8 @@ internal final class RedisDataDecoder: ByteToMessageDecoder {
         case .notYetParsed:
             return .needMoreData
 
-        case .parsed(let redisData):
-            ctx.fireChannelRead(wrapInboundOut(redisData))
+        case .parsed(let RESPValue):
+            ctx.fireChannelRead(wrapInboundOut(RESPValue))
             buffer.moveReaderIndex(forwardBy: position)
             return .continue
         }
@@ -36,13 +36,13 @@ extension UInt8 {
     static let colon: UInt8 = 0x3A
 }
 
-extension RedisDataDecoder {
-    enum _RedisDataDecodingState {
+extension RESPDecoder {
+    enum _RESPValueDecodingState {
         case notYetParsed
-        case parsed(RedisData)
+        case parsed(RESPValue)
     }
 
-    func _parse(at position: inout Int, from buffer: inout ByteBuffer) throws -> _RedisDataDecodingState {
+    func _parse(at position: inout Int, from buffer: inout ByteBuffer) throws -> _RESPValueDecodingState {
         guard let token = buffer.copyBytes(at: position, length: 1)?.first else { return .notYetParsed }
 
         position += 1
@@ -120,7 +120,7 @@ extension RedisDataDecoder {
     }
 
     /// See https://redis.io/topics/protocol#resp-bulk-strings
-    func _parseBulkString(at position: inout Int, from buffer: inout ByteBuffer) throws -> _RedisDataDecodingState {
+    func _parseBulkString(at position: inout Int, from buffer: inout ByteBuffer) throws -> _RESPValueDecodingState {
         guard let size = try _parseInteger(at: &position, from: &buffer) else { return .notYetParsed }
 
         // Redis sends '-1' to represent a null string
@@ -153,12 +153,12 @@ extension RedisDataDecoder {
     }
 
     /// See https://redis.io/topics/protocol#resp-arrays
-    func _parseArray(at position: inout Int, from buffer: inout ByteBuffer) throws -> _RedisDataDecodingState {
+    func _parseArray(at position: inout Int, from buffer: inout ByteBuffer) throws -> _RESPValueDecodingState {
         guard let arraySize = try _parseInteger(at: &position, from: &buffer) else { return .notYetParsed }
         guard arraySize > -1 else { return .parsed(.null) }
         guard arraySize > 0 else { return .parsed(.array([])) }
 
-        var array = [_RedisDataDecodingState](repeating: .notYetParsed, count: arraySize)
+        var array = [_RESPValueDecodingState](repeating: .notYetParsed, count: arraySize)
         for index in 0..<arraySize {
             guard buffer.readableBytes - position > 0 else { return .notYetParsed }
 
@@ -171,7 +171,7 @@ extension RedisDataDecoder {
             }
         }
 
-        let values = try array.map { state -> RedisData in
+        let values = try array.map { state -> RESPValue in
             guard case .parsed(let value) = state else {
                 throw RedisError(
                     identifier: "parseArray",

Sources/NIORedis/Coders/RedisDataEncoder.swift renamed to Sources/NIORedis/ChannelHandlers/RESPEncoder.swift

@@ -1,19 +1,19 @@
 import Foundation
 import NIO
 
-/// Handles outgoing `RedisData` on the wire by encoding it to the Redis RESP protocol.
+/// Handles outgoing `RESPValue` on the wire by encoding it to the Redis RESP protocol.
 ///
 /// See: https://redis.io/topics/protocol
-internal final class RedisDataEncoder: MessageToByteEncoder {
+internal final class RESPEncoder: MessageToByteEncoder {
     /// See `MessageToByteEncoder.OutboundIn`
-    typealias OutboundIn = RedisData
+    typealias OutboundIn = RESPValue
 
-    /// See `RedisDataEncoder.encode(ctx:data:out:)`
-    func encode(ctx: ChannelHandlerContext, data: RedisData, out: inout ByteBuffer) throws {
+    /// See `RESPEncoder.encode(ctx:data:out:)`
+    func encode(ctx: ChannelHandlerContext, data: RESPValue, out: inout ByteBuffer) throws {
         out.write(bytes: _encode(data: data))
     }
 
-    func _encode(data: RedisData) -> Data {
+    func _encode(data: RESPValue) -> Data {
         switch data {
         case .simpleString(let string):
             return "+\(string)\r\n".convertedToData()

Sources/NIORedis/Channel/RedisMessenger.swift renamed to Sources/NIORedis/ChannelHandlers/RedisMessenger.swift

@@ -9,9 +9,9 @@ internal final class RedisMessenger {
     private var channelContext: ChannelHandlerContext?
 
     /// Queue of promises waiting to receive an incoming response value from an outgoing message.
-    private var waitingResponseQueue: [EventLoopPromise<RedisData>]
+    private var waitingResponseQueue: [EventLoopPromise<RESPValue>]
     /// Queue of unset outgoing messages, with the oldest messages at the end of the array.
-    private var outgoingMessageQueue: [RedisData]
+    private var outgoingMessageQueue: [RESPValue]
 
     /// Creates a new handler that works on the specified `EventLoop`.
     init(on eventLoop: EventLoop) {
@@ -20,9 +20,9 @@ internal final class RedisMessenger {
         self.eventLoop = eventLoop
     }
 
-    /// Adds a complete message encoded as `RedisData` to the queue and returns an `EventLoopFuture` that resolves
+    /// Adds a complete message encoded as `RESPValue` to the queue and returns an `EventLoopFuture` that resolves
     /// the response from Redis.
-    func enqueue(_ output: RedisData) -> EventLoopFuture<RedisData> {
+    func enqueue(_ output: RESPValue) -> EventLoopFuture<RESPValue> {
         // ensure that we are on the event loop before modifying our data
         guard eventLoop.inEventLoop else {
             return eventLoop.submit({}).then { return self.enqueue(output) }
@@ -33,7 +33,7 @@ internal final class RedisMessenger {
 
         // every outgoing message is expected to receive some form of response, so create a promise that we'll resolve
         // with the response
-        let promise = eventLoop.makePromise(of: RedisData.self)
+        let promise = eventLoop.makePromise(of: RESPValue.self)
         waitingResponseQueue.insert(promise, at: 0)
 
         // if we have a context for writing, flush the outgoing queue
@@ -59,10 +59,10 @@ internal final class RedisMessenger {
 
 extension RedisMessenger: ChannelInboundHandler {
     /// See `ChannelInboundHandler.InboundIn`
-    public typealias InboundIn = RedisData
+    public typealias InboundIn = RESPValue
 
     /// See `ChannelInboundHandler.OutboundOut`
-    public typealias OutboundOut = RedisData
+    public typealias OutboundOut = RESPValue
 
     /// Invoked by NIO when the channel for this handler has become active, receiving a context that is ready to
     /// send messages.
@@ -85,7 +85,7 @@ extension RedisMessenger: ChannelInboundHandler {
     }
 
     /// Invoked by NIO when a read has been fired from earlier in the response chain. This forwards the unwrapped
-    /// `RedisData` to the response at the front of the queue.
+    /// `RESPValue` to the response at the front of the queue.
     /// See `ChannelInboundHandler.channelRead(ctx:data:)`
     public func channelRead(ctx: ChannelHandlerContext, data: NIOAny) {
         let input = unwrapInboundIn(data)

Sources/NIORedis/Commands/BasicCommands.swift

@@ -7,23 +7,23 @@ extension NIORedisConnection {
     ///
     /// https://redis.io/commands/select
     public func select(_ id: Int) -> EventLoopFuture<Void> {
-        return command("SELECT", [RedisData(bulk: id.description)])
+        return command("SELECT", [RESPValue(bulk: id.description)])
             .map { _ in return () }
     }
 
     /// Request for authentication in a password-protected Redis server.
     ///
     /// https://redis.io/commands/auth
     public func authorize(with password: String) -> EventLoopFuture<Void> {
-        return command("AUTH", [RedisData(bulk: password)]).map { _ in return () }
+        return command("AUTH", [RESPValue(bulk: password)]).map { _ in return () }
     }
 
     /// Removes the specified keys. A key is ignored if it does not exist.
     ///
     /// https://redis.io/commands/del
     /// - Returns: A future number of keys that were removed.
     public func delete(_ keys: String...) -> EventLoopFuture<Int> {
-        let keyArgs = keys.map { RedisData(bulk: $0) }
+        let keyArgs = keys.map { RESPValue(bulk: $0) }
         return command("DEL", keyArgs)
             .thenThrowing { res in
                 guard let count = res.int else {
@@ -41,7 +41,7 @@ extension NIORedisConnection {
     ///     - after: The lifetime (in seconds) the key will expirate at.
     /// - Returns: A future bool indicating if the expiration was set or not.
     public func expire(_ key: String, after deadline: Int) -> EventLoopFuture<Bool> {
-        return command("EXPIRE", [RedisData(bulk: key), RedisData(bulk: deadline.description)])
+        return command("EXPIRE", [RESPValue(bulk: key), RESPValue(bulk: deadline.description)])
             .thenThrowing { res in
                 guard let value = res.int else {
                     throw RedisError(identifier: "expire", reason: "Unexpected response: \(res)")
@@ -56,7 +56,7 @@ extension NIORedisConnection {
     ///
     /// https://redis.io/commands/get
     public func get(_ key: String) -> EventLoopFuture<String?> {
-        return command("GET", [RedisData(bulk: key)])
+        return command("GET", [RESPValue(bulk: key)])
             .map { return $0.string }
     }
 
@@ -66,7 +66,7 @@ extension NIORedisConnection {
     ///
     /// https://redis.io/commands/set
     public func set(_ key: String, to value: String) -> EventLoopFuture<Void> {
-        return command("SET", [RedisData(bulk: key), RedisData(bulk: value)])
+        return command("SET", [RESPValue(bulk: key), RESPValue(bulk: value)])
             .map { _ in return () }
     }
 }