Add @PublishedDefault for ObservableObject

Sources/Defaults/PublishedDefault.swift

@@ -0,0 +1,124 @@
+import Combine
+
+/**
+PublishedDefault will trigger `objectWillChange` in the `ObservableObject` when the value is changed.
+
+- Important: By default, `PublishedDefault` does not observe changes made to the corresponding value outside of the `PublishedDefault`.
+Only changes made via this `@PublishedDefault` will trigger `objectWillChange`.
+
+To ensure that changes made to Defaults elsewhere also trigger `objectWillChange`, you need to call `observeDefaults` once in the `ObservableObject`.
+
+```swift
+extension Defaults.Keys {
+    static let opacity = Key<Double>("opacity", default: 1)
+}
+
+class ViewModel: ObservableObject {
+    @PublishedDefault(.opacity) var opacity
+
+    init() {
+        observeDefaults()
+    }
+}
+```
+*/
+@propertyWrapper
+public class PublishedDefault<Value: _DefaultsSerializable> {
+    private let key: Defaults.Key<Value>
+    private var defaultPublisher: AnyPublisher<Value, Never>?
+    private var objectSubscription: AnyCancellable?
+
+    private var value: Value {
+        get { Defaults[key] }
+        set { Defaults[key] = newValue }
+    }
+
+    public init(_ key: Defaults.Key<Value>) {
+        self.key = key
+    }
+
+    /**
+    The getter/setter in a `ObservableObject`.
+    */
+    public static subscript<Object: AnyObject>(
+        _enclosingInstance instance: Object,
+        wrapped _: ReferenceWritableKeyPath<Object, Value>,
+        storage storageKeyPath: ReferenceWritableKeyPath<Object, PublishedDefault>
+    ) -> Value {
+        get {
+            instance[keyPath: storageKeyPath].value
+        }
+        set {
+            // Skip if subscrition is already acting
+            if instance[keyPath: storageKeyPath].objectSubscription == nil,
+               let observable = instance as? any ObservableObject,
+               let objectWillChange = observable.objectWillChange as any Publisher as? ObservableObjectPublisher
+            {
+                objectWillChange.send()
+            }
+            instance[keyPath: storageKeyPath].value = newValue
+        }
+    }
+
+    @available(*, unavailable, message: "@PublishedDefault is only available on properties of AnyObject")
+    public var wrappedValue: Value {
+        get { value }
+        set { value = newValue }
+    }
+
+    public var projectedValue: some Publisher<Value, Never> {
+        if defaultPublisher == nil {
+            defaultPublisher = Defaults.publisher(key, options: [.initial])
+                .map(\.newValue)
+                .eraseToAnyPublisher()
+        }
+        return defaultPublisher!
+    }
+
+    /**
+    Reset the key back to its default value.
+
+    ```swift
+    extension Defaults.Keys {
+        static let opacity = Key<Double>("opacity", default: 1)
+    }
+
+    class ViewModel: ObservableObject {
+        @PublishedDefault(.opacity) var opacity
+
+        func reset() {
+            _opacity.reset()
+        }
+    }
+    ```
+    */
+    public func reset() {
+        key.reset()
+    }
+}
+
+// A type-erase protocol used to subscribe Defaults on ObservableObject.
+protocol _PublishedDefaultProtocol {
+    func subscribe(to publisher: ObservableObjectPublisher)
+}
+
+extension PublishedDefault: _PublishedDefaultProtocol {
+    func subscribe(to publisher: ObservableObjectPublisher) {
+        objectSubscription = projectedValue
+            .dropFirst()
+            .sink { _ in
+                publisher.send()
+            }
+    }
+}
+
+public extension ObservableObject where ObjectWillChangePublisher == ObservableObjectPublisher {
+    /**
+    Begin observing the Default value so that changes made to Defaults outside of the ObservableObject will also trigger objectWillChange.
+    */
+    func observeDefaults() {
+        for (_, property) in Mirror(reflecting: self).children {
+            (property as? _PublishedDefaultProtocol)?.subscribe(to: objectWillChange)
+        }
+    }
+}

Tests/DefaultsTests/DefaultsPublishedDefaultTests.swift

@@ -0,0 +1,83 @@
+import XCTest
+import Combine
+import Defaults
+
+@available(macOS 11.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
+private extension Defaults.Keys {
+    static let opacity = Key<Double>("opacity", default: 0.5)
+}
+
+@available(macOS 11.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
+final class ViewModel: ObservableObject {
+    @PublishedDefault(.opacity) var opacity
+}
+
+@available(macOS 11.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
+final class DefaultsPublishedDefaultTests: XCTestCase {
+
+    var cancellables: [AnyCancellable] = []
+
+    override func setUp() {
+        Defaults.removeAll()
+    }
+
+    override func tearDown() {
+        cancellables = []
+    }
+
+    func testObjectWillChange() {
+        let viewModel = ViewModel()
+        let objectExpectation = expectation(description: "Expected ObservableObject's fire")
+
+        viewModel.objectWillChange
+            .sink {
+                objectExpectation.fulfill()
+            }
+            .store(in: &cancellables)
+
+        viewModel.opacity = 1
+        waitForExpectations(timeout: 1)
+
+        XCTAssertEqual(viewModel.opacity, 1)
+        XCTAssertEqual(Defaults[.opacity], 1)
+    }
+
+    func testProjectValue() {
+        let viewModel = ViewModel()
+        let valueExpectation = expectation(description: "Expected Opacity Value")
+        var receivedValue: Double?
+
+        viewModel.$opacity
+            // skip the initial value
+            .dropFirst()
+            .sink { newValue in
+                receivedValue = newValue
+                valueExpectation.fulfill()
+            }
+            .store(in: &cancellables)
+
+        // Changing value via Defaults directly also fire the projecttedValue
+        Defaults[.opacity] = 1
+        waitForExpectations(timeout: 1)
+        XCTAssertEqual(receivedValue, 1)
+    }
+
+    func testObservation() {
+        let viewModel = ViewModel()
+        // To enable Defaults observation, call observeDefaults.
+        viewModel.observeDefaults()
+        let objectExpectation = expectation(description: "Expected ObservableObject's fire")
+
+        viewModel.objectWillChange
+            .sink {
+                objectExpectation.fulfill()
+            }
+            .store(in: &cancellables)
+
+        // Change value via Defaults instead of ObservableObject itself
+        Defaults[.opacity] = 1
+        waitForExpectations(timeout: 1)
+
+        XCTAssertEqual(viewModel.opacity, 1)
+    }
+}