Merge branch 'develop' into release/add-pr-list-tooling

Author: loremattei

Networking/Networking.xcodeproj/project.pbxproj

@@ -0,0 +1,17 @@
+import Foundation
+
+
+// MARK: - Dictionary: JSON Encoding Helpers
+//
+extension Dictionary where Key: Encodable, Value: Encodable {
+
+    /// Returns a String with the JSON Representation of the receiver.
+    ///
+    func toJSONEncoded() -> String? {
+        guard let encoded = try? JSONEncoder().encode(self) else {
+            return nil
+        }
+
+        return String(data: encoded, encoding: .utf8)
+    }
+}

Networking/Networking/Extensions/Dictionary+Woo.swift

@@ -0,0 +1,94 @@
+import Foundation
+
+
+// MARK: - KeyedDecodingContainer: Bulletproof JSON Decoding.
+//
+extension KeyedDecodingContainer {
+
+    /// Decodes the specified Type for a given Key (if present).
+    ///
+    /// This method *does NOT throw*. We want this behavior so that if a malformed entity is received, we just skip it, rather
+    /// than breaking the entire parsing chain.
+    ///
+    func failsafeDecodeIfPresent<T>(_ type: T.Type, forKey key: KeyedDecodingContainer<K>.Key) -> T? where T : Decodable {
+        do {
+            return try decodeIfPresent(type, forKey: key)
+        } catch {
+            return nil
+        }
+    }
+
+    /// Decodes a String for the specified key. Supported Encodings = [String, Integer]
+    ///
+    /// This method *does NOT throw*. We want this behavior so that if a malformed entity is received, we just skip it, rather
+    /// than breaking the entire parsing chain.
+    ///
+    func failsafeDecodeIfPresent(stringForKey key: KeyedDecodingContainer<K>.Key) -> String? {
+        if let string = failsafeDecodeIfPresent(String.self, forKey: key) {
+            return string
+        }
+
+        if let stringAsInteger = failsafeDecodeIfPresent(Int.self, forKey: key) {
+            return String(stringAsInteger)
+        }
+
+        return nil
+    }
+
+    /// Decodes an Integer for the specified key. Supported Encodings = [Integer / String]
+    ///
+    /// This method *does NOT throw*. We want this behavior so that if a malformed entity is received, we just skip it, rather
+    /// than breaking the entire parsing chain.
+    ///
+    func failsafeDecodeIfPresent(integerForKey key: KeyedDecodingContainer<K>.Key) -> Int? {
+        if let integer = failsafeDecodeIfPresent(Int.self, forKey: key) {
+            return integer
+        }
+
+        if let integerAsString = failsafeDecodeIfPresent(String.self, forKey: key) {
+            return Int(integerAsString)
+        }
+
+        return nil
+    }
+
+    /// Decodes a Boolean for the specified key. Supported Encodings = [Bool / String]
+    ///
+    /// This method *does NOT throw*. We want this behavior so that if a malformed entity is received, we just skip it, rather
+    /// than breaking the entire parsing chain.
+    ///
+    func failsafeDecodeIfPresent(booleanForKey key: KeyedDecodingContainer<K>.Key) -> Bool? {
+        if let bool = failsafeDecodeIfPresent(Bool.self, forKey: key) {
+            return bool
+        }
+
+        if let boolAsInteger = failsafeDecodeIfPresent(Int.self, forKey: key) {
+            return boolAsInteger == DecodingConstants.booleanTrueAsInteger
+        }
+
+        return nil
+    }
+}
+
+
+// MARK: - Convenience Decoding Methods
+//
+extension KeyedDecodingContainer {
+
+    /// Decodes a NSRange entity encoded as an array of integers, under the specified key.
+    ///
+    func decode(arrayEncodedRangeForKey key: KeyedDecodingContainer<K>.Key) throws -> NSRange {
+        let indices = try decode([Int].self, forKey: key)
+        guard let start = indices.first, let end = indices.last, indices.count == 2 else {
+            throw DecodingError.dataCorruptedError(forKey: key, in: self, debugDescription: "Invalid Indices")
+        }
+
+        return NSRange(location: start, length: end - start)
+    }
+}
+
+
+// MARK: - Private Decoding Constants
+private enum DecodingConstants {
+    static let booleanTrueAsInteger = 1
+}

Networking/Networking/Extensions/KeyedDecodingContainer+Woo.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+
+/// Mapper: NoteHashes Collection
+///
+struct NoteHashListMapper: Mapper {
+
+    /// (Attempts) to convert an instance of Data into an array of NoteHash Entities.
+    ///
+    func map(response: Data) throws -> [NoteHash] {
+        return try JSONDecoder().decode(NoteHashesEnvelope.self, from: response).hashes
+    }
+}
+
+
+/// NoteHashesEnvelope Disposable Entity:
+/// This entity allows us to parse [NoteHash] with JSONDecoder.
+///
+private struct NoteHashesEnvelope: Decodable {
+    let hashes: [NoteHash]
+
+    private enum CodingKeys: String, CodingKey {
+        case hashes = "notes"
+    }
+}

Networking/Networking/Mapper/NoteHashListMapper.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+
+/// Mapper: Notifications List
+///
+struct NoteListMapper: Mapper {
+
+    /// (Attempts) to convert an instance of Data into an array of Note Entities.
+    ///
+    func map(response: Data) throws -> [Note] {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .formatted(DateFormatter.Defaults.dateTimeFormatter)
+
+        return try decoder.decode(NotesEnvelope.self, from: response).notes
+    }
+}
+
+
+/// NotesEnvelope Disposable Entity:
+/// `Notifications` endpoint returns the updated order document in the `notes` key. This entity
+/// allows us to do parse all the things with JSONDecoder.
+///
+private struct NotesEnvelope: Decodable {
+    let notes: [Note]
+
+    private enum CodingKeys: String, CodingKey {
+        case notes = "notes"
+    }
+}

Networking/Networking/Mapper/NoteListMapper.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+
+/// Mapper: Success Result
+///
+struct SuccessResultMapper: Mapper {
+
+    /// (Attempts) to extract the `success` flag from a given JSON Encoded response.
+    ///
+    func map(response: Data) throws -> Bool {
+        return try JSONDecoder().decode(SuccessResult.self, from: response).success
+    }
+}
+
+
+/// Success Flag Envelope
+///
+private struct SuccessResult: Decodable {
+
+    /// Success Flag
+    ///
+    let success: Bool
+
+    /// Coding Keys!
+    ///
+    private enum CodingKeys: String, CodingKey {
+        case success
+    }
+}

Networking/Networking/Mapper/SuccessResultMapper.swift

@@ -0,0 +1,35 @@
+import Foundation
+
+
+/// WordPress.com Request Error
+///
+public struct DotcomError: Error, Decodable {
+
+    /// Error Code
+    ///
+    public let code: String
+
+    /// Descriptive Message
+    ///
+    public let message: String?
+
+
+    /// Coding Keys!
+    ///
+    private enum CodingKeys: String, CodingKey {
+        case code = "error"
+        case message
+    }
+}
+
+
+/// Known Dotcom Errors
+///
+extension DotcomError {
+
+    /// Something went wrong. We just don't know what!
+    ///
+    static var unknown: DotcomError {
+        return DotcomError(code: "unknown", message: nil)
+    }
+}

Networking/Networking/Model/DotcomError.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+
+// MARK: - MetaContainer: Simple API to query the "Notification Meta" Collection.
+//
+public struct MetaContainer {
+
+    /// The actual Meta Payload.
+    ///
+    let payload: [String: AnyCodable]
+
+
+    /// Returns the Meta Link associated with the specified key (if any).
+    ///
+    public func link(forKey key: Keys) -> String? {
+        let links = container(ofType: [String: String].self, forKey: .links)
+        return links?[key.rawValue]
+    }
+
+    /// Returns the Meta ID associated with the specified key (if any).
+    ///
+    public func identifier(forKey key: Keys) -> Int? {
+        let identifiers = container(ofType: [String: Int].self, forKey: .ids)
+        return identifiers?[key.rawValue]
+    }
+
+    /// Returns the Meta Container for a given key (if any).
+    ///
+    private func container<T>(ofType type: T.Type, forKey key: Containers) -> T? {
+        return payload[key.rawValue]?.value as? T
+    }
+}
+
+
+// MARK: - Nested Types
+//
+extension MetaContainer {
+
+    /// Known Meta Containers
+    ///
+    enum Containers: String {
+        case ids
+        case links
+        case titles
+    }
+
+    /// Known Meta Keys
+    ///
+    public enum Keys: String {
+        case comment
+        case home
+        case post
+        case reply  = "reply_comment"
+        case site
+        case user
+    }
+}