facet_generate 0.16.0

Generate Swift, Kotlin and TypeScript from types annotated with `#[derive(Facet)]`
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

import Foundation

struct NotDiffable: Codable {
    init() {}
}

enum InternallyTagged: Codable, KeyPathMutable {
    case anonymousStruct(atomic: NotDiffable)

    enum `Type`: String, CodingKey, Codable, CaseIterable {
        case anonymousStruct
    }

    var type: `Type` {
        switch self {
        case .anonymousStruct: return .anonymousStruct
        }
    }

    private enum CodingKeys: String, CodingKey {
        case type
        case atomic
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let type = try container.decode(`Type`.self, forKey: .type)
        switch type {
        case .anonymousStruct:
            let atomic = try container.decode(NotDiffable.self, forKey: .atomic)
            self = .anonymousStruct(atomic: atomic)
        }
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case .anonymousStruct(let atomic):
            try container.encode(`Type`.anonymousStruct, forKey: .type)
            try container.encode(atomic, forKey: .atomic)
        }
    }

    public mutating func patch<C: Collection>(_ patch: PatchOperation, at keyPath: C) where C.Element == KeyPathElement {
        guard let variant = keyPath.first else {
            return apply(patch)
        }
        switch (self, variant) {
        case var (.anonymousStruct(atomic), .variant(key: "anonymousStruct", tag: _)):
            guard keyPath.count >= 2 else {
                return Logs.error("`InternallyTagged.anonymousStruct` expects a field after the variant in the key path")
            }
            let field = keyPath[keyPath.index(keyPath.startIndex, offsetBy:1)]
            switch field {
            case .field("atomic"):
                guard keyPath.count == 2 else {
                    return Logs.error("`InternallyTagged.anonymousStruct.atomic` expects an atomic update")
                }
                guard case let .update(value) = patch else {
                    return Logs.error("`InternallyTagged.anonymousStruct.atomic` is atomic and only support update patches")
                }

                guard let atomic = NotDiffable.fromAnyCodable(value) else {
                    return Logs.error("Trying to update `atomic` with \(value.value)")
                }
                
                self = .anonymousStruct(atomic: atomic)
            default:
                Logs.error("`InternallyTagged.anonymousStruct` has no patchable value at path \"\(field)\"")
            }
        default:
            Logs.error("Trying to apply a patch for the wrong variant: expect `\(self)`, received `\(variant)`")
        }
    }

    private mutating func apply(_ patch: PatchOperation) {
        switch patch {
        case let .update(value):
            if let newValue = value.value as? InternallyTagged {
                self = newValue
            } else if let newValue = InternallyTagged.fromAnyCodable(value) {
                self = newValue
            } else {
                Logs.error("Trying to update `InternallyTagged` with \(value.value)")
            }
        case .splice:
            Logs.error("`InternallyTagged` does not support splice operations.")
        }
    }
}