remove warnings

Author: tanner0101

Sources/PostgresKit/PostgresDataDecoder.swift

@@ -1,6 +1,5 @@
 import Foundation
 
-#warning("TODO: move to codable kit")
 struct DecoderUnwrapper: Decodable {
     let decoder: Decoder
     init(from decoder: Decoder) {
@@ -21,8 +20,6 @@ public struct PostgresDataDecoder {
         }
     }
 
-    #warning("TODO: finish implementing")
-
     private final class _Decoder: Decoder {
         var codingPath: [CodingKey] {
             return []
@@ -42,7 +39,6 @@ public struct PostgresDataDecoder {
         }
 
         func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key : CodingKey {
-            #warning("TODO: use NIOFoundationCompat")
             var buffer = self.data.value!
             let data = buffer.readBytes(length: buffer.readableBytes)!
             let unwrapper = try JSONDecoder().decode(DecoderUnwrapper.self, from: Data(data))
@@ -67,62 +63,6 @@ public struct PostgresDataDecoder {
             return self.decoder.data.value == nil
         }
 
-        func decode(_ type: Bool.Type) throws -> Bool {
-            fatalError()
-        }
-
-        func decode(_ type: String.Type) throws -> String {
-            return self.decoder.data.string!
-        }
-
-        func decode(_ type: Double.Type) throws -> Double {
-            return self.decoder.data.double!
-        }
-
-        func decode(_ type: Float.Type) throws -> Float {
-            return self.decoder.data.float!
-        }
-
-        func decode(_ type: Int.Type) throws -> Int {
-            return self.decoder.data.int!
-        }
-
-        func decode(_ type: Int8.Type) throws -> Int8 {
-            fatalError()
-        }
-
-        func decode(_ type: Int16.Type) throws -> Int16 {
-            fatalError()
-        }
-
-        func decode(_ type: Int32.Type) throws -> Int32 {
-            fatalError()
-        }
-
-        func decode(_ type: Int64.Type) throws -> Int64 {
-            return self.decoder.data.int64!
-        }
-
-        func decode(_ type: UInt.Type) throws -> UInt {
-            fatalError()
-        }
-
-        func decode(_ type: UInt8.Type) throws -> UInt8 {
-            fatalError()
-        }
-
-        func decode(_ type: UInt16.Type) throws -> UInt16 {
-            fatalError()
-        }
-
-        func decode(_ type: UInt32.Type) throws -> UInt32 {
-            fatalError()
-        }
-
-        func decode(_ type: UInt64.Type) throws -> UInt64 {
-            fatalError()
-        }
-
         func decode<T>(_ type: T.Type) throws -> T where T : Decodable {
             if let convertible = T.self as? PostgresDataConvertible.Type {
                 return convertible.init(postgresData: self.decoder.data)! as! T

Sources/PostgresKit/PostgresDataEncoder.swift

@@ -47,11 +47,8 @@ public struct PostgresDataEncoder {
         }
     }
 
-    #warning("TODO: fix fatal errors")
-
     struct DoJSON: Error {}
 
-    #warning("TODO: move to encodable kit")
     struct Wrapper: Encodable {
         let encodable: Encodable
         init(_ encodable: Encodable) {
@@ -112,70 +109,16 @@ public struct PostgresDataEncoder {
             // data already null
         }
 
-        mutating func encode(_ value: Bool) throws {
-            switch value {
-            case true:
-                self.encoder.data = PostgresData(int: 1)
-            case false:
-                self.encoder.data = PostgresData(int: 0)
-            }
-        }
-
-        mutating func encode(_ value: String) throws {
-            self.encoder.data = PostgresData(string: value)
-        }
-
-        mutating func encode(_ value: Double) throws {
-            self.encoder.data = PostgresData(double: value)
-        }
-
-        mutating func encode(_ value: Float) throws {
-            self.encoder.data = PostgresData(float: value)
-        }
-
-        mutating func encode(_ value: Int) throws {
-            self.encoder.data = PostgresData(int: value)
-        }
-
-        mutating func encode(_ value: Int8) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: Int16) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: Int32) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: Int64) throws {
-            self.encoder.data = PostgresData(int64: value)
-        }
-
-        mutating func encode(_ value: UInt) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: UInt8) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: UInt16) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: UInt32) throws {
-            fatalError()
-        }
-
-        mutating func encode(_ value: UInt64) throws {
-            fatalError()
-        }
-
         mutating func encode<T>(_ value: T) throws where T : Encodable {
             if let value = value as? PostgresDataConvertible {
-                self.encoder.data = value.postgresData!
+                guard let data = value.postgresData else {
+                    let context = DecodingError.Context(
+                        codingPath: self.codingPath,
+                        debugDescription: "Could not convert \(value) to PostgresData"
+                    )
+                    throw DecodingError.typeMismatch(T.self, context)
+                }
+                self.encoder.data = data
             } else {
                 try value.encode(to: self.encoder)
             }

Tests/PostgresKitTests/PostgresKitTests.swift

@@ -33,7 +33,7 @@ class PostgresKitTests: XCTestCase {
         let pool = ConnectionPool(config: .init(maxConnections: 12), source: db)
         defer { try! pool.close().wait() }
         self.measure {
-            for i in 1...100 {
+            for _ in 1...100 {
                 _ = try! pool.withConnection { conn in
                     return conn.query("SELECT 1;")
                 }.wait()