Merge pull request #30 from Mordil/29-replace-data

Mordil · web-flow · commit b3c1afa27aa2 · 2019-04-01T09:25:06.000-07:00
Replace `Foundation.Data` with `[UInt8]` type everywhere
diff --git a/Sources/NIORedis/ChannelHandlers/RedisCommandHandler.swift b/Sources/NIORedis/ChannelHandlers/RedisCommandHandler.swift
@@ -1,4 +1,4 @@
-import Foundation
+import struct Foundation.UUID
 import Logging
 import NIO
 
diff --git a/Sources/NIORedis/Commands/BasicCommands.swift b/Sources/NIORedis/Commands/BasicCommands.swift
@@ -1,4 +1,3 @@
-import Foundation
 import NIO
 
 extension RedisClient {
diff --git a/Sources/NIORedis/Commands/SetCommands.swift b/Sources/NIORedis/Commands/SetCommands.swift
@@ -1,4 +1,3 @@
-import Foundation
 import NIO
 
 // MARK: General
diff --git a/Sources/NIORedis/Extensions/NIO/ClientBootstrap.swift b/Sources/NIORedis/Extensions/NIO/ClientBootstrap.swift
@@ -1,4 +1,3 @@
-import Foundation
 import NIO
 
 extension ClientBootstrap {
diff --git a/Sources/NIORedis/RESP/RESPDecoder.swift b/Sources/NIORedis/RESP/RESPDecoder.swift
@@ -1,4 +1,3 @@
-import Foundation
 import NIO
 
 extension UInt8 {
@@ -143,7 +142,7 @@ extension RESPDecoder {
         guard size > 0 else {
             // Move the tip of the message position
             position += 2
-            return .parsed(.bulkString(Data()))
+            return .parsed(.bulkString([]))
         }
 
         guard let bytes = buffer.copyBytes(at: position, length: expectedRemainingMessageSize) else {
@@ -154,9 +153,9 @@ extension RESPDecoder {
         // of the bulk string content
         position += expectedRemainingMessageSize
 
-        return .parsed(
-            .bulkString(Data(bytes[ ..<size ]))
-        )
+        return .parsed(.bulkString(
+            .init(bytes[..<size])
+        ))
     }
 
     /// See [https://redis.io/topics/protocol#resp-arrays](https://redis.io/topics/protocol#resp-arrays)
diff --git a/Sources/NIORedis/RESP/RESPValue.swift b/Sources/NIORedis/RESP/RESPValue.swift
@@ -1,26 +1,26 @@
-import Foundation
-
 /// A representation of a Redis Serialization Protocol (RESP) primitive value.
 ///
 /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
 public enum RESPValue {
     case null
     case simpleString(String)
-    case bulkString(Data)
+    case bulkString([UInt8])
     case error(RedisError)
     case integer(Int)
     case array([RESPValue])
 
     /// Initializes a `bulkString` by converting the provided string input.
     public init(bulk: String) {
-        self = .bulkString(Data(bulk.utf8))
+        let bytes = [UInt8](bulk.utf8)
+        self = .bulkString(bytes)
     }
 }
 
 extension RESPValue: ExpressibleByStringLiteral {
     /// Initializes a bulk string from a String literal
     public init(stringLiteral value: String) {
-        self = .bulkString(Data(value.utf8))
+        let bytes = [UInt8](value.utf8)
+        self = .bulkString(bytes)
     }
 }
 
@@ -51,15 +51,15 @@ extension RESPValue {
     public var string: String? {
         switch self {
         case .simpleString(let string): return string
-        case .bulkString(let data): return String(bytes: data, encoding: .utf8)
+        case .bulkString(let bytes): return String(bytes: bytes, encoding: .utf8)
         default: return nil
         }
     }
 
-    /// Extracted binary data from `bulkString` representations.
-    public var data: Data? {
-        guard case .bulkString(let data) = self else { return nil }
-        return data
+    /// Extracted byte representation from `bulkString` values.
+    public var bytes: [UInt8]? {
+        guard case let .bulkString(bytes) = self else { return nil }
+        return bytes
     }
 
     /// Extracted container of data elements from `array` representations.
diff --git a/Sources/NIORedis/RESP/RESPValueConvertible.swift b/Sources/NIORedis/RESP/RESPValueConvertible.swift
@@ -1,5 +1,3 @@
-import Foundation
-
 /// Capable of converting to / from `RESPValue`.
 public protocol RESPValueConvertible {
     init?(_ value: RESPValue)
@@ -39,7 +37,7 @@ extension String: RESPValueConvertible {
 
     /// See `RESPValueConvertible.convertedToRESPValue()`
     public func convertedToRESPValue() -> RESPValue {
-        return .bulkString(Data(self.utf8))
+        return .bulkString(.init(self.utf8))
     }
 }
 
@@ -56,7 +54,7 @@ extension FixedWidthInteger {
 
     /// See `RESPValueConvertible.convertedToRESPValue()`
     public func convertedToRESPValue() -> RESPValue {
-        return .bulkString(Data(self.description.utf8))
+        return .bulkString(.init(self.description.utf8))
     }
 }
 
@@ -80,7 +78,7 @@ extension Double: RESPValueConvertible {
 
     /// See `RESPValueConvertible.convertedToRESPValue()`
     public func convertedToRESPValue() -> RESPValue {
-        return .bulkString(Data(self.description.utf8))
+        return .bulkString(.init(self.description.utf8))
     }
 }
 
@@ -93,19 +91,7 @@ extension Float: RESPValueConvertible {
 
     /// See `RESPValueConvertible.convertedToRESPValue()`
     public func convertedToRESPValue() -> RESPValue {
-        return .bulkString(Data(self.description.utf8))
-    }
-}
-
-extension Data: RESPValueConvertible {
-    public init?(_ value: RESPValue) {
-        guard let data = value.data else { return nil }
-        self = data
-    }
-
-    /// See `RESPValueConvertible.convertedToRESPValue()`
-    public func convertedToRESPValue() -> RESPValue {
-        return .bulkString(self)
+        return .bulkString(.init(self.description.utf8))
     }
 }
 
diff --git a/Sources/NIORedis/RedisClient.swift b/Sources/NIORedis/RedisClient.swift
@@ -1,5 +1,5 @@
+import struct Foundation.UUID
 import Logging
-import Foundation
 import NIO
 import NIOConcurrencyHelpers
 
diff --git a/Sources/NIORedis/RedisError.swift b/Sources/NIORedis/RedisError.swift
@@ -1,4 +1,5 @@
-import Foundation
+import protocol Foundation.LocalizedError
+import class Foundation.Thread
 
 /// Errors thrown while working with Redis.
 public struct RedisError: CustomDebugStringConvertible, CustomStringConvertible, LocalizedError {
diff --git a/Sources/NIORedis/RedisPipeline.swift b/Sources/NIORedis/RedisPipeline.swift
@@ -1,4 +1,4 @@
-import Foundation
+import struct Foundation.UUID
 import Logging
 
 /// An object that provides a mechanism to "pipeline" multiple Redis commands in sequence,
diff --git a/Tests/NIORedisTests/ChannelHandlers/RESPDecoder+B2MDTests.swift b/Tests/NIORedisTests/ChannelHandlers/RESPDecoder+B2MDTests.swift
@@ -39,8 +39,7 @@ final class RESPDecoderByteToMessageDecoderTests: XCTestCase {
 
     func testDecoding_complete_movesReaderIndex() throws {
         for message in RESPDecoderByteToMessageDecoderTests.completeMessages {
-            let messageByteSize = message.convertedToData()
-            XCTAssertEqual(try decodeTest(message).1, messageByteSize.count)
+            XCTAssertEqual(try decodeTest(message).1, message.bytes.count)
         }
     }
 
diff --git a/Tests/NIORedisTests/ChannelHandlers/RESPDecoder+ParsingTests.swift b/Tests/NIORedisTests/ChannelHandlers/RESPDecoder+ParsingTests.swift
@@ -43,35 +43,35 @@ final class RESPDecoderParsingTests: XCTestCase {
         XCTAssertEqual(parseTest_singleValue(input: "$0\r\n\r\n")?.string, "")
         XCTAssertEqual(parseTest_singleValue(input: "$1\r\n!\r\n")?.string, "!")
         XCTAssertEqual(
-            parseTest_singleValue(input: "$1\r\n".convertedToData() + Data([0xa3]) + "\r\n".convertedToData())?.data,
-            Data([0xa3])
+            parseTest_singleValue(input: "$1\r\n".bytes + [0xa3] + "\r\n".bytes)?.bytes,
+            [0xa3]
         )
         XCTAssertEqual(
-            parseTest_singleValue(input: "$1\r\n".convertedToData() + Data([0xba]) + "\r\n".convertedToData())?.data,
-            Data([0xba])
+            parseTest_singleValue(input: "$1\r\n".bytes + [0xba] + "\r\n".bytes)?.bytes,
+            [0xba]
         )
     }
 
     func testParsing_with_bulkString_multiple() throws {
         let t1 = try parseTest_twoValues(withChunks: ["$3\r", "\naaa\r\n$", "4\r\nnio!\r\n"])
-        XCTAssertTrue(t1.0?.data?.count == 3)
-        XCTAssertTrue(t1.1?.data?.count == 4)
+        XCTAssertTrue(t1.0?.bytes?.count == 3)
+        XCTAssertTrue(t1.1?.bytes?.count == 4)
 
-        let chunks: [Data] = [
-            "$3\r".convertedToData(),
-            "\n".convertedToData() + Data([0xAA, 0xA3, 0xFF]) + "\r\n$".convertedToData(),
-            "4\r\n".convertedToData() + Data([0xbb, 0x3a, 0xba, 0xFF]) + "\r\n".convertedToData()
+        let chunks: [[UInt8]] = [
+            "$3\r".bytes,
+            "\n".bytes + [0xAA, 0xA3, 0xFF] + "\r\n$".bytes,
+            "4\r\n".bytes + [0xbb, 0x3a, 0xba, 0xFF] + "\r\n".bytes
         ]
         let t2 = try parseTest_twoValues(withChunks: chunks)
-        XCTAssertTrue(t2.0?.data?.count == 3)
-        XCTAssertTrue(t2.1?.data?.count == 4)
+        XCTAssertTrue(t2.0?.bytes?.count == 3)
+        XCTAssertTrue(t2.1?.bytes?.count == 4)
     }
 
     func testParsing_with_arrays() {
         XCTAssertEqual(parseTest_singleValue(input: "*1\r\n+!\r\n")?.array?.count, 1)
         XCTAssertEqual(parseTest_singleValue(input: "*2\r\n*1\r\n:1\r\n:3\r\n")?.array?.count, 2)
-        XCTAssertEqual(parseTest_singleValue(input: "*0\r\n".convertedToData())?.array?.count, 0)
-        XCTAssertNil(parseTest_singleValue(input: "*-1\r\n".convertedToData())?.array)
+        XCTAssertEqual(parseTest_singleValue(input: "*0\r\n".bytes)?.array?.count, 0)
+        XCTAssertNil(parseTest_singleValue(input: "*-1\r\n".bytes)?.array)
     }
 
     func testParsing_with_arrays_multiple() throws {
@@ -80,10 +80,10 @@ final class RESPDecoderParsingTests: XCTestCase {
         XCTAssertTrue(t1.1?.array?.count == 0)
 
         let t2 = try parseTest_twoValues(withChunks: [
-            "*-1\r".convertedToData(),
-            "\n".convertedToData(),
-            "*1\r".convertedToData(),
-            "\n+£\r\n".convertedToData()
+            "*-1\r".bytes,
+            "\n".bytes,
+            "*1\r".bytes,
+            "\n+£\r\n".bytes
         ])
         XCTAssertTrue(t2.0?.array == nil)
         XCTAssertTrue(t2.1?.array?.count == 1)
@@ -120,11 +120,11 @@ final class RESPDecoderParsingTests: XCTestCase {
 
     /// See parse_Test_singleValue(input:) String
     private func parseTest_singleValue(input: String) -> RESPValue? {
-        return parseTest_singleValue(input: input.convertedToData())
+        return parseTest_singleValue(input: input.bytes)
     }
 
     /// Takes a collection of bytes representing a complete message and returns the data
-    private func parseTest_singleValue(input: Data) -> RESPValue? {
+    private func parseTest_singleValue(input: [UInt8]) -> RESPValue? {
         return runParse(offset: 0) { decoder, position, buffer in
             buffer.writeBytes(input)
             guard case .parsed(let result)? = try? decoder.parse(at: &position, from: &buffer) else { return nil }
@@ -134,13 +134,13 @@ final class RESPDecoderParsingTests: XCTestCase {
 
     /// See parseTest_recursive(withCunks:) [Data]
     private func parseTest_twoValues(withChunks messageChunks: [String]) throws -> (RESPValue?, RESPValue?) {
-        return try parseTest_twoValues(withChunks: messageChunks.map({ $0.convertedToData() }))
+        return try parseTest_twoValues(withChunks: messageChunks.map({ $0.bytes }))
     }
 
     /// Takes a collection of incomplete byte messages that produce exactly two decoded RESPValue.
     /// The expected pattern of messages should be [incomplete, remaining, incomplete, remaining]
     /// - Returns: The first and second decoded data
-    private func parseTest_twoValues(withChunks messageChunks: [Data]) throws -> (RESPValue?, RESPValue?) {
+    private func parseTest_twoValues(withChunks messageChunks: [[UInt8]]) throws -> (RESPValue?, RESPValue?) {
         let decoder = RESPDecoder()
         var buffer = allocator.buffer(capacity: messageChunks.joined().count)
 
@@ -263,12 +263,12 @@ extension RESPDecoderParsingTests {
 
     func testParsing_bulkString_withNoSize_returnsEmpty() throws {
         let result = parseTestBulkString("$0\r\n\r\n")
-        XCTAssertEqual(result?.data?.count, 0)
+        XCTAssertEqual(result?.bytes?.count, 0)
     }
 
     func testParsing_bulkString_withSize_returnsContent() throws {
         let result = parseTestBulkString("$1\r\n1\r\n")
-        XCTAssertEqual(result?.data?.count, 1)
+        XCTAssertEqual(result?.bytes?.count, 1)
     }
 
     func testParsing_bulkString_withNull_returnsNil() throws {
@@ -278,18 +278,18 @@ extension RESPDecoderParsingTests {
 
     func testParsing_bulkString_handlesRawBytes() throws {
         let bytes: [UInt8] = [0x00, 0x01, 0x02, 0x03, 0x0A, 0xFF]
-        let data = "$\(bytes.count)\r\n".convertedToData() + Data(bytes) + "\r\n".convertedToData()
+        let allBytes = "$\(bytes.count)\r\n".bytes + bytes + "\r\n".bytes
 
-        let result = parseTestBulkString(data)
+        let result = parseTestBulkString(allBytes)
 
-        XCTAssertEqual(result?.data?.count, bytes.count)
+        XCTAssertEqual(result?.bytes?.count, bytes.count)
     }
 
     private func parseTestBulkString(_ input: String) -> RESPValue? {
-        return parseTestBulkString(input.convertedToData())
+        return parseTestBulkString(input.bytes)
     }
 
-    private func parseTestBulkString(_ input: Data) -> RESPValue? {
+    private func parseTestBulkString(_ input: [UInt8]) -> RESPValue? {
         return runParse { decoder, position, buffer in
             buffer.writeBytes(input)
             guard case .parsed(let result) = try decoder._parseBulkString(at: &position, from: &buffer) else {
@@ -318,7 +318,7 @@ extension RESPDecoderParsingTests {
         XCTAssertEqual(result?.count, 3)
         XCTAssertEqual(result?[0].int, 3)
         XCTAssertEqual(result?[1].string, "OK")
-        XCTAssertEqual(result?[2].data?.count, 1)
+        XCTAssertEqual(result?[2].bytes?.count, 1)
     }
 
     func testParsing_array_handlesNullElements() {
@@ -340,10 +340,10 @@ extension RESPDecoderParsingTests {
     }
 
     private func parseTestArray(_ input: String) -> RESPValue? {
-        return parseTestArray(input.convertedToData())
+        return parseTestArray(input.bytes)
     }
 
-    private func parseTestArray(_ input: Data) -> RESPValue? {
+    private func parseTestArray(_ input: [UInt8]) -> RESPValue? {
         return runParse { decoder, position, buffer in
             buffer.writeBytes(input)
             guard case .parsed(let result) = try decoder._parseArray(at: &position, from: &buffer) else { return nil }
diff --git a/Tests/NIORedisTests/ChannelHandlers/RESPDecoderTests.swift b/Tests/NIORedisTests/ChannelHandlers/RESPDecoderTests.swift
diff --git a/Tests/NIORedisTests/ChannelHandlers/RESPEncoder+ParsingTests.swift b/Tests/NIORedisTests/ChannelHandlers/RESPEncoder+ParsingTests.swift
diff --git a/Tests/NIORedisTests/ChannelHandlers/RESPEncoderTests.swift b/Tests/NIORedisTests/ChannelHandlers/RESPEncoderTests.swift
diff --git a/Tests/NIORedisTests/RedisPipelineTests.swift b/Tests/NIORedisTests/RedisPipelineTests.swift
diff --git a/Tests/NIORedisTests/Utilities/String.swift b/Tests/NIORedisTests/Utilities/String.swift

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import Foundation`
	`1`	`+import struct Foundation.UUID`
`2`	`2`	`import Logging`
`3`	`3`	`import NIO`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-import Foundation`
`2`	`1`	`import NIO`
`3`	`2`
`4`	`3`	`extension RedisClient {`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,3 @@`
`1`		`-import Foundation`
`2`		`-`
`3`	`1`	/// Capable of converting to / from `RESPValue`.
`4`	`2`	`public protocol RESPValueConvertible {`
`5`	`3`	`init?(_ value: RESPValue)`
`@@ -39,7 +37,7 @@ extension String: RESPValueConvertible {`
`39`	`37`
`40`	`38`	/// See `RESPValueConvertible.convertedToRESPValue()`
`41`	`39`	`public func convertedToRESPValue() -> RESPValue {`
`42`		`- return .bulkString(Data(self.utf8))`
	`40`	`+ return .bulkString(.init(self.utf8))`
`43`	`41`	`}`
`44`	`42`	`}`
`45`	`43`
`@@ -56,7 +54,7 @@ extension FixedWidthInteger {`
`56`	`54`
`57`	`55`	/// See `RESPValueConvertible.convertedToRESPValue()`
`58`	`56`	`public func convertedToRESPValue() -> RESPValue {`
`59`		`- return .bulkString(Data(self.description.utf8))`
	`57`	`+ return .bulkString(.init(self.description.utf8))`
`60`	`58`	`}`
`61`	`59`	`}`
`62`	`60`
`@@ -80,7 +78,7 @@ extension Double: RESPValueConvertible {`
`80`	`78`
`81`	`79`	/// See `RESPValueConvertible.convertedToRESPValue()`
`82`	`80`	`public func convertedToRESPValue() -> RESPValue {`
`83`		`- return .bulkString(Data(self.description.utf8))`
	`81`	`+ return .bulkString(.init(self.description.utf8))`
`84`	`82`	`}`
`85`	`83`	`}`
`86`	`84`
`@@ -93,19 +91,7 @@ extension Float: RESPValueConvertible {`
`93`	`91`
`94`	`92`	/// See `RESPValueConvertible.convertedToRESPValue()`
`95`	`93`	`public func convertedToRESPValue() -> RESPValue {`
`96`		`- return .bulkString(Data(self.description.utf8))`
`97`		`- }`
`98`		`-}`
`99`		`-`
`100`		`-extension Data: RESPValueConvertible {`
`101`		`- public init?(_ value: RESPValue) {`
`102`		`- guard let data = value.data else { return nil }`
`103`		`- self = data`
`104`		`- }`
`105`		`-`
`106`		- /// See `RESPValueConvertible.convertedToRESPValue()`
`107`		`- public func convertedToRESPValue() -> RESPValue {`
`108`		`- return .bulkString(self)`
	`94`	`+ return .bulkString(.init(self.description.utf8))`
`109`	`95`	`}`
`110`	`96`	`}`
`111`	`97`