decision environment, cleanup

MaximBazarov · Jan 6, 2024 · 06f55f6 · 06f55f6
1 parent e6cc476
commit 06f55f6
Show file tree

Hide file tree

Showing 16 changed files with 100 additions and 622 deletions.
diff --git a/Decide-Tests/SwiftUI_Tests.swift b/Decide-Tests/SwiftUI_Tests.swift
@@ -15,7 +15,6 @@
 import SwiftUI
 import Decide
 import XCTest
-import DecideTesting
 
 @MainActor final class SwiftUI_Tests: XCTestCase {
 
@@ -33,8 +32,8 @@ import DecideTesting
     struct UpdateStr: ValueDecision {
         var newValue: String
 
-        func mutate(_ env: Decide.DecisionEnvironment) {
-//            env[\.Storage.$str] = newValue
+        func mutate(_ env: DecisionEnvironment) {
+            var x = env[\Storage.$str]
         }
     }
 

diff --git a/Decide/Binding/Bind.swift b/Decide/Binding/Bind.swift
@@ -47,23 +47,16 @@ public final class Bind<Root, Value> where Root: StateRoot {
         get {
             let wrapperInstance = instance[keyPath: storageKeyPath]
             let root = wrapperInstance.environment.get(Root.self)
-            let observableValue = root[keyPath: wrapperInstance.statePath]
-
-#warning("""
-TODO: Squash updates of any values this instance is subscribed to,
-to one update to instance.
-""")
-            let observer = Observer(wrapperInstance) { [weak instance] in
+            let observableValue = root[keyPath: wrapperInstance.statePath.appending(path: \.storage)]
+            let observer = Observer(instance) { [weak instance] in
                 instance?.onChange()
             }
-
-
             return observableValue.getValueSubscribing(observer: observer)
         }
         set {
             let wrapperInstance = instance[keyPath: storageKeyPath]
             let root = wrapperInstance.environment.get(Root.self)
-            let observableValue = root[keyPath: wrapperInstance.statePath]
+            let observableValue = root[keyPath: wrapperInstance.statePath.appending(path: \.storage)]
             observableValue.set(value: newValue)
         }
     }

diff --git a/Decide/Binding/SwiftUIBinding.swift b/Decide/Binding/SwiftUIBinding.swift
@@ -31,7 +31,7 @@ public struct SwiftUIBind<
     public var wrappedValue: Value {
         get {
             environment
-                .get(Root.self)[keyPath: statePath]
+                .get(Root.self)[keyPath: statePath.appending(path: \.storage)]
                 .getValueSubscribing(
                     observer: Observer(publisher) { [weak publisher] in
                         publisher?.objectWillChange.send()
@@ -40,7 +40,7 @@ public struct SwiftUIBind<
         }
         nonmutating set {
             environment
-                .get(Root.self)[keyPath: statePath]
+                .get(Root.self)[keyPath: statePath.appending(path: \.storage)]
                 .set(value: newValue)
         }
     }

diff --git a/Decide/Decision/Decision.swift b/Decide/Decision/Decision.swift
@@ -51,38 +51,76 @@ public typealias EnvironmentMutation = (DecisionEnvironment) -> Void
     }
 
     func make(decision: Decision) {
-        /**
-         1. Create a temporary environment, something to enable transactions
-         2. Perform that mutation
-         3. Execute effects
-         */
         decision.mutate(self)
+        observers.forEach { $0.send() }
+        performEffects()
+        observers = []
     }
 
-    func perform(effect: Effect) {
-
+    func performEffects() {
+
+    }
+
+    private var observers: Set<Observer> = []
+
+    func getValue<Root: StateRoot, Value>(_ path: KeyPath<Root, ValueStorage<Value>>) -> Value {
+        let root = environment.get(Root.self)
+        let observableValue = root[keyPath: path]
+        return observableValue.value
+    }
+
+    func set<Root: StateRoot, Value>(value newValue: Value, path: KeyPath<Root, ValueStorage<Value>>) {
+        let root = environment.get(Root.self)
+        let observableValue = root[keyPath: path]
+        // We pop all observers of the observable values mutated by the decision.
+        // it also will prevent their observers to be notified
+        // until decision application is complete.
+        let valueObservers = observableValue.observation.popObservers()
+        // then we add them into set of all the observers that we will notify
+        // when all states affected by decision are mutated.
+        // this way we squash all the updates to:
+        // Each observer notified **once**,
+        // regardless how many values were updated.
+        // E.g. some object observes `A.a` `A.b` and `B.a` where A and B are roots.
+        // and .a .b are values.
+        // Decision updates all of them, but since it's a single observer (Observer.id), 
+        // it will only get one update.
+        observers.formUnion(valueObservers)
+        observableValue.value = newValue
     }
 
     /**
      Subscript to direct read/write access to any atomic state.
      */
-    public subscript<Root: StateRoot, Value>(_ path: KeyPath<Root, ObservableValue<Value>>) -> Value {
-        get {
-            let root = environment.get(Root.self)
-            let observableValue = root[keyPath: path]
-            return observableValue.wrappedValue
-        }
-        set {
-            let root = environment.get(Root.self)
-            let observableValue = root[keyPath: path]
-            observableValue.set(value: newValue)
-        }
+    public subscript<
+        Root: StateRoot,
+        Value
+    >(
+        _ path: KeyPath<Root, ObservableValue<Value>>
+    ) -> Value {
+        get { getValue(path.appending(path: \.storage)) }
+        set { set(value: newValue, path: path.appending(path: \.storage)) }
+    }
+
+    public subscript<
+        Root: StateRoot,
+        Wrapper: ObservableValueStorageWrapper,
+        Value
+    >(
+        path: KeyPath<Root, Wrapper>
+    ) -> Value where Wrapper.Value == Value {
+        get { getValue(path.appending(path: \.storage)) }
+        set { set(value: newValue, path: path.appending(path: \.storage)) }
     }
 
     /**
      Subscript to direct read/write access to any identified state.
      */
-    public subscript<Identifier: Hashable, Root: IdentifiedStateRoot, Value>(
+    public subscript<
+        Identifier: Hashable,
+        Root: IdentifiedStateRoot,
+        Value
+    >(
         _ path: KeyPath<Root, ObservableValue<Value>>,
         at id: Identifier
     ) -> Value where Root.Identifier == Identifier {
@@ -93,7 +131,7 @@ public typealias EnvironmentMutation = (DecisionEnvironment) -> Void
         }
         set {
             let root = environment.get(Root.self, at: id)
-            let observableValue = root[keyPath: path]
+            let observableValue = root[keyPath: path.appending(path: \.storage)]
             observableValue.set(value: newValue)
         }
     }

diff --git a/Decide/Environment/Observability.swift b/Decide/Environment/Observability.swift
@@ -16,9 +16,14 @@ import Foundation
 
 /// Holds a week reference to actual observer, notifies only if object still exist.
 public final class Observer: Hashable {
-    private(set) var notify: () -> Void
+    private var notify: () -> Void
     private var id: ObjectIdentifier
 
+    public func send() {
+        print("notified \(id)")
+        notify()
+    }
+
     @MainActor init<O: AnyObject>(_ observer: O, notify: @escaping () -> Void) {
         self.notify = notify
         self.id = ObjectIdentifier(observer)
@@ -51,7 +56,7 @@ public final class Observer: Hashable {
 
     func sendAll() {
         let observers = popObservers()
-        observers.forEach { $0.notify() }
+        observers.forEach { $0.send() }
     }
 }
 
diff --git a/Decide/Macros.swift b/Decide/Macros.swift
diff --git a/Decide/Persistency/Persistency.swift b/Decide/Persistency/Persistency.swift
@@ -21,15 +21,16 @@ import Foundation
  */
 @propertyWrapper
 @MainActor
-public final class Persistent<Value>: ObservableValueWrapper {
+public final class Persistent<Value>: ObservableValueStorageWrapper {
     public var wrappedValue: Value { storage.value }
+    public var projectedValue: Persistent<Value> { self }
     public var storage: ValueStorage<Value>
 
     public init(wrappedValue: @autoclosure @escaping () -> Value) {
         self.storage = ValueStorage(initialValue: wrappedValue)
     }
 
-    public init<Wrapper: ObservableValueWrapper>(wrappedValue: Wrapper) where Wrapper.Value == Value {
+    public init<Wrapper: ObservableValueStorageWrapper>(wrappedValue: Wrapper) where Wrapper.Value == Value {
         self.storage = wrappedValue.storage
     }
 }
diff --git a/Decide/RemoteValue/RemoteSync.swift b/Decide/RemoteValue/RemoteSync.swift
@@ -22,15 +22,16 @@ import Foundation
  */
 @propertyWrapper
 @MainActor
-public final class RemoteValue<Value>: ObservableValueWrapper {
+public final class RemoteValue<Value>: ObservableValueStorageWrapper {
     public var wrappedValue: Value { storage.value }
+    public var projectedValue: RemoteValue<Value> { self }
     public var storage: ValueStorage<Value>
 
     public init(wrappedValue: @autoclosure @escaping () -> Value) {
         self.storage = ValueStorage(initialValue: wrappedValue)
     }
 
-    public init<Wrapper: ObservableValueWrapper>(wrappedValue: Wrapper) where Wrapper.Value == Value {
+    public init<Wrapper: ObservableValueStorageWrapper>(wrappedValue: Wrapper) where Wrapper.Value == Value {
         self.storage = wrappedValue.storage
     }
 }
diff --git a/Decide/State/ObservableValue.swift b/Decide/State/ObservableValue.swift
@@ -17,9 +17,10 @@
  Contains the reference to the storage of the value.
  */
 @MainActor
-public protocol ObservableValueWrapper {
+public protocol ObservableValueStorageWrapper {
     associatedtype Value
     var storage: ValueStorage<Value> { get }
+    var projectedValue: Self { get }
 }
 
 /**
@@ -28,35 +29,20 @@ public protocol ObservableValueWrapper {
  */
 @propertyWrapper
 @MainActor
-public final class ObservableValue<Value> {
-
+public final class ObservableValue<Value>: ObservableValueStorageWrapper {
     public var wrappedValue: Value {
-        valueStorage.value
+        storage.value
     }
 
     public var projectedValue: ObservableValue<Value> { self }
 
-    var valueStorage: ValueStorage<Value>
-    var observation = ObserverStorage()
+    public var storage: ValueStorage<Value>
 
     public init(wrappedValue: @autoclosure @escaping () -> Value) {
-        self.valueStorage = ValueStorage(initialValue: wrappedValue)
+        self.storage = ValueStorage(initialValue: wrappedValue)
     }
 
-    public init<Wrapper: ObservableValueWrapper>(wrappedValue: Wrapper) where Wrapper.Value == Value {
-        self.valueStorage = wrappedValue.storage
+    public init<Wrapper: ObservableValueStorageWrapper>(wrappedValue: Wrapper) where Wrapper.Value == Value {
+        self.storage = wrappedValue.storage
     }
 }
-
-extension ObservableValue {
-    public func getValueSubscribing(observer: Observer) -> Value {
-        observation.subscribe(observer)
-        return wrappedValue
-    }
-
-    public func set(value newValue: Value) {
-        valueStorage.value = newValue
-        observation.sendAll()
-    }
-}
-
diff --git a/Decide/State/ValueStorage.swift b/Decide/State/ValueStorage.swift
@@ -16,6 +16,7 @@ import Foundation
 
 @MainActor
 public final class ValueStorage<Value> {
+    var observation = ObserverStorage()
     public var initialValue: () -> Value
     public var value: Value {
         get {
@@ -39,3 +40,15 @@ public final class ValueStorage<Value> {
         self.initialValue = initialValue
     }
 }
+
+extension ValueStorage {
+    public func getValueSubscribing(observer: Observer) -> Value {
+        observation.subscribe(observer)
+        return value
+    }
+
+    public func set(value newValue: Value) {
+        value = newValue
+        observation.sendAll()
+    }
+}
diff --git a/DecideMacros-Tests/Decide_Tests.swift b/DecideMacros-Tests/Decide_Tests.swift
diff --git a/DecideMacros/EnvironmentObservable.swift b/DecideMacros/EnvironmentObservable.swift