WIP: editable datasources

Sources/LiveObject.swift

@@ -0,0 +1,285 @@
+//
+//  LiveObject.swift
+//  CoreStore
+//
+//  Copyright © 2018 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import CoreData
+
+#if canImport(Combine)
+import Combine
+
+#endif
+
+#if canImport(SwiftUI)
+import SwiftUI
+
+#endif
+
+
+// MARK: - LiveObject
+
+@dynamicMemberLookup
+public final class LiveObject<O: DynamicObject>: Identifiable, Hashable {
+
+    // MARK: Public
+
+    public typealias SectionID = String
+    public typealias ItemID = O.ObjectID
+
+    public var snapshot: SnapshotType {
+
+        return self.lazySnapshot
+    }
+
+    public private(set) lazy var object: O = self.context.fetchExisting(self.id)!
+
+
+    // MARK: Identifiable
+
+    public let id: O.ObjectID
+
+
+    // MARK: Equatable
+
+    public static func == (_ lhs: LiveObject, _ rhs: LiveObject) -> Bool {
+
+        return lhs.id == rhs.id
+            && lhs.context == rhs.context
+    }
+
+
+    // MARK: Hashable
+
+    public func hash(into hasher: inout Hasher) {
+
+        hasher.combine(self.id)
+        hasher.combine(self.context)
+    }
+
+
+    // MARK: LiveResult
+
+    public typealias ObjectType = O
+
+    public typealias SnapshotType = ObjectSnapshot<O>
+
+
+    // MARK: Internal
+
+    internal convenience init(id: ID, context: NSManagedObjectContext) {
+
+        self.init(id: id, context: context, initializer: ObjectSnapshot<O>.init(id:context:))
+    }
+
+
+    // MARK: FilePrivate
+
+    fileprivate let rawObjectWillChange: Any?
+
+    fileprivate init(id: O.ObjectID, context: NSManagedObjectContext, initializer: @escaping (NSManagedObjectID, NSManagedObjectContext) -> ObjectSnapshot<O>) {
+
+        self.id = id
+        self.context = context
+        if #available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 15.0, *) {
+
+            #if canImport(Combine)
+            self.rawObjectWillChange = ObservableObjectPublisher()
+
+            #else
+            self.rawObjectWillChange = nil
+
+            #endif
+        }
+        else {
+
+            self.rawObjectWillChange = nil
+        }
+        self.observer = NotificationCenter.default.addObserver(
+            forName: .NSManagedObjectContextObjectsDidChange,
+            object: context,
+            queue: .main,
+            using: { [weak self] (notification) in
+
+                guard let self = self, let userInfo = notification.userInfo else {
+
+                    return
+                }
+                let updatedObjects = (userInfo[NSUpdatedObjectsKey] as! NSSet? ?? [])
+                let mergedObjects = (userInfo[NSRefreshedObjectsKey] as! NSSet? ?? [])
+                guard mergedObjects.contains(where: { ($0 as! NSManagedObject).objectID == id })
+                    || updatedObjects.contains(where: { ($0 as! NSManagedObject).objectID == id }) else {
+
+                        return
+                }
+                self.$lazySnapshot.reset({ initializer(id, context) })
+                if #available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 15.0, *) {
+
+                    self.willChange()
+                }
+            }
+        )
+
+        self.$lazySnapshot.initialize({ initializer(id, context) })
+    }
+
+
+    // MARK: Private
+    
+    private let context: NSManagedObjectContext
+    private var observer: NSObjectProtocol?
+
+    @Internals.LazyNonmutating(uninitialized: ())
+    private var lazySnapshot: ObjectSnapshot<O>
+}
+
+
+#if canImport(Combine)
+import Combine
+
+// MARK: - LiveObject: LiveResult
+
+@available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 15.0, *)
+extension LiveObject: LiveResult {
+
+    // MARK: ObservableObject
+
+    public var objectWillChange: ObservableObjectPublisher {
+
+        return self.rawObjectWillChange! as! ObservableObjectPublisher
+    }
+
+    public func willChange() {
+
+        #if canImport(Combine)
+
+        #if canImport(SwiftUI)
+        withAnimation {
+
+            self.objectWillChange.send()
+        }
+
+        #else
+        self.objectWillChange.send()
+
+        #endif
+
+        #endif
+    }
+
+    public func didChange() {
+
+        // TODO:
+    }
+}
+
+#endif
+
+
+// MARK: - LiveObject where O: NSManagedObject
+
+@available(*, unavailable, message: "KeyPaths accessed from @dynamicMemberLookup types can't generate KVC keys yet (https://bugs.swift.org/browse/SR-11351)")
+extension LiveObject where O: NSManagedObject {
+
+    // MARK: Public
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<V: AllowedObjectiveCKeyPathValue>(dynamicMember member: KeyPath<O, V>) -> V {
+
+        fatalError()
+//        return self.snapshot[dynamicMember: member]
+    }
+}
+
+
+// MARK: - LiveObject where O: CoreStoreObject
+
+extension LiveObject where O: CoreStoreObject {
+
+    // MARK: Public
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<V>(dynamicMember member: KeyPath<O, ValueContainer<O>.Required<V>>) -> V {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<V>(dynamicMember member: KeyPath<O, ValueContainer<O>.Optional<V>>) -> V? {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<V>(dynamicMember member: KeyPath<O, TransformableContainer<O>.Required<V>>) -> V {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<V>(dynamicMember member: KeyPath<O, TransformableContainer<O>.Optional<V>>) -> V? {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<D>(dynamicMember member: KeyPath<O, RelationshipContainer<O>.ToOne<D>>) -> D? {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<D>(dynamicMember member: KeyPath<O, RelationshipContainer<O>.ToManyOrdered<D>>) -> [D] {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<D>(dynamicMember member: KeyPath<O, RelationshipContainer<O>.ToManyUnordered<D>>) -> Set<D> {
+
+        return self.snapshot[dynamicMember: member]
+    }
+
+    /**
+     Returns the value for the property identified by a given key.
+     */
+    public subscript<T>(dynamicMember member: KeyPath<O, T>) -> T {
+
+        return self.object[keyPath: member]
+    }
+}