Handle Data encodings (#57)

* Add Base64 decoding for Data.

* Allow DataProtocol for Data

Author: rnapier

Sources/BetterCodable/Base64Strategy.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+/// Decodes `String` values as a Base64-encoded `Data`.
+///
+/// Decodes strictly valid Base64. This does not handle b64url encoding, invalid padding, or unknown characters.
+public struct Base64Strategy<DataType: MutableDataProtocol>: DataValueCodableStrategy {
+    public static func decode(_ value: String) throws -> DataType {
+        if let data = Data(base64Encoded: value) {
+            return DataType(data)
+        } else {
+            throw DecodingError.dataCorrupted(.init(codingPath: [], debugDescription: "Invalid Base64 Format!"))
+        }
+    }
+
+    public static func encode(_ data: DataType) -> String {
+        Data(data).base64EncodedString()
+    }
+}

Sources/BetterCodable/DataValue.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+/// A protocol for providing a custom strategy for encoding and decoding data as strings.
+///
+/// `DataValueCodableStrategy` provides a generic strategy type that the `DataValue` property wrapper can use to inject
+///  custom strategies for encoding and decoding data values.
+///
+public protocol DataValueCodableStrategy {
+    associatedtype DataType: MutableDataProtocol
+    static func decode(_ value: String) throws -> DataType
+    static func encode(_ data: DataType) -> String
+}
+
+/// Decodes and encodes data using a strategy type.
+///
+/// `@DataValue` decodes data using a `DataValueCodableStrategy` which provides custom decoding and encoding functionality.
+@propertyWrapper
+public struct DataValue<Coder: DataValueCodableStrategy> {
+    public var wrappedValue: Coder.DataType
+
+    public init(wrappedValue: Coder.DataType) {
+        self.wrappedValue = wrappedValue
+    }
+}
+
+extension DataValue: Decodable {
+    public init(from decoder: Decoder) throws {
+        self.wrappedValue = try Coder.decode(String(from: decoder))
+    }
+}
+
+extension DataValue: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        try Coder.encode(wrappedValue).encode(to: encoder)
+    }
+}
+
+extension DataValue: Equatable where Coder.DataType: Equatable {}
+extension DataValue: Hashable where Coder.DataType: Hashable {}

Tests/BetterCodableTests/DataValueTests.swift

@@ -0,0 +1,40 @@
+import XCTest
+import BetterCodable
+
+class DataValueTests: XCTestCase {
+    func testDecodingAndEncodingBase64String() throws {
+        struct Fixture: Codable {
+            @DataValue<Base64Strategy> var data: Data
+        }
+        let jsonData = #"{"data":"QmV0dGVyQ29kYWJsZQ=="}"#.data(using: .utf8)!
+
+        let fixture = try JSONDecoder().decode(Fixture.self, from: jsonData)
+        XCTAssertEqual(fixture.data, Data("BetterCodable".utf8))
+
+        let outputJSON = try JSONEncoder().encode(fixture)
+        XCTAssertEqual(outputJSON, jsonData)
+    }
+
+    func testDecodingMalformedBase64Fails() throws {
+        struct Fixture: Codable {
+            @DataValue<Base64Strategy> var data: Data
+        }
+        let jsonData = #"{"data":"invalidBase64!"}"#.data(using: .utf8)!
+
+        XCTAssertThrowsError(try JSONDecoder().decode(Fixture.self, from: jsonData))
+    }
+
+    func testDecodingAndEncodingBase64StringToArray() throws {
+        struct Fixture: Codable {
+            @DataValue<Base64Strategy> var data: [UInt8]
+        }
+        let jsonData = #"{"data":"QmV0dGVyQ29kYWJsZQ=="}"#.data(using: .utf8)!
+
+        let fixture = try JSONDecoder().decode(Fixture.self, from: jsonData)
+        XCTAssertEqual(fixture.data, Array("BetterCodable".utf8))
+
+        let outputJSON = try JSONEncoder().encode(fixture)
+        XCTAssertEqual(outputJSON, jsonData)
+    }
+
+}