tech(Observable) Remove observable object (#74)

pjechris · web-flow · commit 7e963048dc8b · 2025-01-03T18:54:27.000+01:00
diff --git a/.editorconfig b/.editorconfig
@@ -0,0 +1,10 @@
+root = true
+
+[*]
+end_of_line = lf
+trim_trailing_whitespace = true
+
+# 4 space indentation
+[*.swift]
+indent_style = space
+indent_size = 4
diff --git a/Sources/CohesionKit/EntityStore.swift b/Sources/CohesionKit/EntityStore.swift
@@ -254,7 +254,7 @@ extension EntityStore {
     @discardableResult
     public func update<T: Identifiable>(_ type: T.Type, id: T.ID, modifiedAt: Stamp? = nil, update: Update<T>) -> Bool {
         transaction {
-            guard var entity = storage[T.self, id: id]?.ref.value else {
+            guard var entity = storage[T.self, id: id]?.value else {
                 return false
             }
 
@@ -275,7 +275,7 @@ extension EntityStore {
     @discardableResult
     public func update<T: Aggregate>(_ type: T.Type, id: T.ID, modifiedAt: Stamp? = nil, _ update: Update<T>) -> Bool {
         transaction {
-            guard var entity = storage[T.self, id: id]?.ref.value else {
+            guard var entity = storage[T.self, id: id]?.value else {
                 return false
             }
 
@@ -294,7 +294,7 @@ extension EntityStore {
     @discardableResult
     public func update<T: Identifiable>(named: AliasKey<T>, modifiedAt: Stamp? = nil, update: Update<T>) -> Bool {
         transaction {
-            guard let aliasNode = refAliases[named], var content = aliasNode.ref.value.content else {
+            guard let aliasNode = refAliases[named], var content = aliasNode.value.content else {
                 return false
             }
 
@@ -313,7 +313,7 @@ extension EntityStore {
     @discardableResult
     public func update<T: Aggregate>(named: AliasKey<T>, modifiedAt: Stamp? = nil, update: Update<T>) -> Bool {
         transaction {
-            guard let aliasNode = refAliases[named], var content = aliasNode.ref.value.content else {
+            guard let aliasNode = refAliases[named], var content = aliasNode.value.content else {
                 return false
             }
 
@@ -333,7 +333,7 @@ extension EntityStore {
     public func update<C: Collection>(named: AliasKey<C>, modifiedAt: Stamp? = nil, update: Update<C>)
     -> Bool where C.Element: Identifiable {
         transaction {
-            guard let aliasNode = refAliases[named], var content = aliasNode.ref.value.content else {
+            guard let aliasNode = refAliases[named], var content = aliasNode.value.content else {
                 return false
             }
 
@@ -353,7 +353,7 @@ extension EntityStore {
     public func update<C: Collection>(named: AliasKey<C>, modifiedAt: Stamp? = nil, update: Update<C>)
     -> Bool where C.Element: Aggregate {
         transaction {
-            guard let aliasNode = refAliases[named], var content = aliasNode.ref.value.content else {
+            guard let aliasNode = refAliases[named], var content = aliasNode.value.content else {
                 return false
             }
 
diff --git a/Sources/CohesionKit/Observer/EntityObserver.swift b/Sources/CohesionKit/Observer/EntityObserver.swift
@@ -9,22 +9,22 @@ public struct EntityObserver<T> {
     let createObserver: (@escaping OnChange) -> Subscription
 
     init(node: EntityNode<T>, registry: ObserverRegistry) {
-        self.value = node.ref.value
+        self.value = node.value
         self.createObserver = { onChange in
             registry.addObserver(node: node, initial: true, onChange: onChange)
         }
     }
 
     init<Element>(nodes: [EntityNode<Element>], registry: ObserverRegistry) where T == [Element] {
-        self.value = nodes.map(\.ref.value)
+        self.value = nodes.map(\.value)
         self.createObserver = { onChange in
             registry.addObserver(nodes: nodes, initial: true, onChange: onChange)
         }
     }
 
     init<Wrapped>(alias node: EntityNode<AliasContainer<Wrapped>>, registry: ObserverRegistry)
     where T == Optional<Wrapped> {
-        self.init(value: node.ref.value.content) { onChange in
+        self.init(value: node.value.content) { onChange in
             registry.addObserver(node: node, initial: true, onChange: { container in
                 onChange(container.content)
             })
diff --git a/Sources/CohesionKit/Observer/Observable.swift b/Sources/CohesionKit/Observer/Observable.swift
diff --git a/Sources/CohesionKit/Observer/ObserverRegistry.swift b/Sources/CohesionKit/Observer/ObserverRegistry.swift
@@ -36,15 +36,15 @@ class ObserverRegistry {
     /// register an observer to observe changes on an entity node. Everytime `ObserverRegistry` is notified about changes
     /// to this node `onChange` will be called.
     func addObserver<T>(node: EntityNode<T>, key: ObjectKey, initial: Bool = false, onChange: @escaping (T) -> Void) -> Subscription {
-        let handler = Handler { onChange($0.ref.value) }
+        let handler = Handler { onChange($0.value) }
 
         if initial {
           if queue == DispatchQueue.main && Thread.isMainThread {
-            onChange(node.ref.value)
+            onChange(node.value)
           }
           else {
             queue.sync {
-              onChange(node.ref.value)
+              onChange(node.value)
             }
           }
         }
@@ -57,16 +57,16 @@ class ObserverRegistry {
     func addObserver<T>(nodes: [EntityNode<T>], initial: Bool = false, onChange: @escaping ([T]) -> Void) -> Subscription {
         let handler = Handler { (_: EntityNode<T>) in
             // use last value from nodes
-            onChange(nodes.map(\.ref.value))
+            onChange(nodes.map(\.value))
         }
 
         if initial {
           if queue == DispatchQueue.main && Thread.isMainThread {
-            onChange(nodes.map(\.ref.value))
+            onChange(nodes.map(\.value))
           }
           else {
             queue.sync {
-              onChange(nodes.map(\.ref.value))
+              onChange(nodes.map(\.value))
             }
           }
         }
diff --git a/Sources/CohesionKit/Observer/Subscription.swift b/Sources/CohesionKit/Observer/Subscription.swift
@@ -0,0 +1,21 @@
+import Foundation
+
+public class Subscription {
+    public let unsubscribe: () -> Void
+
+    init(unsubscribe: @escaping () -> Void) {
+        var unsubscribed = false
+
+        self.unsubscribe = {
+            if !unsubscribed {
+                unsubscribe()
+            }
+
+            unsubscribed = true
+        }
+    }
+
+    deinit {
+        unsubscribe()
+    }
+}
diff --git a/Sources/CohesionKit/Storage/EntityNode.swift b/Sources/CohesionKit/Storage/EntityNode.swift
@@ -24,8 +24,7 @@ struct EntityMetadata {
 protocol AnyEntityNode: AnyObject {
     associatedtype Value
 
-    var ref: Observable<Value> { get }
-    var value: Any { get }
+    var value: Value { get }
     var metadata: EntityMetadata { get }
     var storageKey: String { get }
 
@@ -47,34 +46,28 @@ class EntityNode<T>: AnyEntityNode {
         let node: any AnyEntityNode
     }
 
-    var value: Any { ref.value }
+    private(set) var value: Value
 
     var metadata = EntityMetadata()
     // FIXME: to delete, it's "just" to have a strong ref and avoid nodes to be deleted. Need a better memory management
     private var childrenNodes: [any AnyEntityNode] = []
 
     var applyChildrenChanges = true
-    /// An observable entity reference
-    let ref: Observable<T>
 
     let storageKey: String
 
-    /// last time the ref.value was changed. Any subsequent change must have a higher value to be applied
+    /// last time `value` was changed. Any subsequent change must have a higher value to be applied
     /// if nil ref has no stamp and any change will be accepted
     private var modifiedAt: Stamp?
     /// entity children
     private(set) var children: [PartialKeyPath<T>: SubscribedChild] = [:]
 
-    init(ref: Observable<T>, key: String, modifiedAt: Stamp?) {
-        self.ref = ref
+    init(_ entity: T, key: String, modifiedAt: Stamp?) {
+        self.value = entity
         self.modifiedAt = modifiedAt
         self.storageKey = key
     }
 
-    convenience init(_ entity: T, key: String, modifiedAt: Stamp?) {
-        self.init(ref: Observable(value: entity), key: key, modifiedAt: modifiedAt)
-    }
-
     convenience init(_ entity: T, modifiedAt: Stamp?) where T: Identifiable {
         let key = "\(T.self)-\(entity.id)"
         self.init(entity, key: key, modifiedAt: modifiedAt)
@@ -89,11 +82,11 @@ class EntityNode<T>: AnyEntityNode {
         }
 
         modifiedAt = newModifiedAt ?? modifiedAt
-        ref.value = newEntity
+        value = newEntity
     }
 
     func nullify() -> Bool {
-        if let value = ref.value as? Nullable {
+        if let value = value as? Nullable {
             do {
                 try updateEntity(value.nullified() as! T, modifiedAt: nil)
                 return true
@@ -126,12 +119,12 @@ class EntityNode<T>: AnyEntityNode {
         }
 
         if let writableKeyPath = keyPath as? WritableKeyPath<T, U.Value> {
-            ref.value[keyPath: writableKeyPath] = child.ref.value
+            value[keyPath: writableKeyPath] = child.value
             return
         }
 
         if let optionalWritableKeyPath = keyPath as? WritableKeyPath<T, U.Value?> {
-            ref.value[keyPath: optionalWritableKeyPath] = child.ref.value
+            value[keyPath: optionalWritableKeyPath] = child.value
             return
         }
 
diff --git a/Tests/CohesionKitTests/Observer/Stub/ObserverRegistryStub.swift b/Tests/CohesionKitTests/Observer/Stub/ObserverRegistryStub.swift
@@ -13,7 +13,7 @@ class ObserverRegistryStub: ObserverRegistry {
     }
 
     func hasPendingChange<T: Equatable>(for entity: T) -> Bool {
-        pendingChangesStub.contains { ($0 as? EntityNode<T>)?.ref.value == entity }
+        pendingChangesStub.contains { ($0 as? EntityNode<T>)?.value == entity }
     }
 
     func hasPendingChange<T>(for _: T.Type) -> Bool {
@@ -22,7 +22,7 @@ class ObserverRegistryStub: ObserverRegistry {
 
     /// number of times change has been inserted for this entity
     func pendingChangeCount<T: Equatable>(for entity: T) -> Int {
-        pendingChangesStub.filter { ($0 as? EntityNode<T>)?.ref.value == entity }.count
+        pendingChangesStub.filter { ($0 as? EntityNode<T>)?.value == entity }.count
     }
 
     func clearPendingChangesStub() {
diff --git a/Tests/CohesionKitTests/RefTests.swift b/Tests/CohesionKitTests/RefTests.swift
diff --git a/Tests/CohesionKitTests/Storage/AliasStorageTests.swift b/Tests/CohesionKitTests/Storage/AliasStorageTests.swift
@@ -6,7 +6,7 @@ class AliasStorageTests: XCTestCase {
         var storage: AliasStorage = [:]
 
         XCTAssertNotNil(storage[safe: .testCollection])
-        XCTAssertNil(storage[safe: .testCollection].ref.value.content)
+        XCTAssertNil(storage[safe: .testCollection].value.content)
     }
 
     func test_subscriptGet_aliasHasSameNameThanAnotherType_itReturnsAliasContainer() {
diff --git a/Tests/CohesionKitTests/Storage/EntityNodeTests.swift b/Tests/CohesionKitTests/Storage/EntityNodeTests.swift
@@ -30,27 +30,27 @@ class EntityNodeTests: XCTestCase {
             try node.updateEntity(newEntity, modifiedAt: startTimestamp)
         )
 
-        XCTAssertEqual(node.value as? RootFixture, startEntity)
+        XCTAssertEqual(node.value, startEntity)
     }
 
     func test_updateEntity_stampIsSup_entityIsUpdated() throws {
         try node.updateEntity(newEntity, modifiedAt: startTimestamp + 1)
 
-        XCTAssertEqual(node.value as? RootFixture, newEntity)
+        XCTAssertEqual(node.value, newEntity)
     }
 
     func test_updateEntity_stampIsInf_entityIsNotUpdated() throws {
         XCTAssertThrowsError(
             try node.updateEntity(newEntity, modifiedAt: startTimestamp - 1)
         )
 
-        XCTAssertEqual(node.value as? RootFixture, startEntity)
+        XCTAssertEqual(node.value, startEntity)
     }
 
     func test_updateEntity_stampIsNil_entityIsUpdated() throws {
         try node.updateEntity(newEntity, modifiedAt: nil)
 
-        XCTAssertEqual(node.value as? RootFixture, newEntity)
+        XCTAssertEqual(node.value, newEntity)
     }
 
     func test_updateEntity_stampIsNil_stampIsNotUpdated() throws {
@@ -94,7 +94,7 @@ class EntityNodeTests: XCTestCase {
 
         node.updateEntityRelationship(childNode)
 
-        XCTAssertEqual(node.ref.value.singleNode, newChild)
+        XCTAssertEqual(node.value.singleNode, newChild)
     }
 
     func test_observeChild_childIsCollection_eachChildIsAdded() {

Original file line number	Diff line number	Diff line change
`@@ -9,22 +9,22 @@ public struct EntityObserver<T> {`
`9`	`9`	`let createObserver: (@escaping OnChange) -> Subscription`
`10`	`10`
`11`	`11`	`init(node: EntityNode<T>, registry: ObserverRegistry) {`
`12`		`- self.value = node.ref.value`
	`12`	`+ self.value = node.value`
`13`	`13`	`self.createObserver = { onChange in`
`14`	`14`	`registry.addObserver(node: node, initial: true, onChange: onChange)`
`15`	`15`	`}`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`init<Element>(nodes: [EntityNode<Element>], registry: ObserverRegistry) where T == [Element] {`
`19`		`- self.value = nodes.map(\.ref.value)`
	`19`	`+ self.value = nodes.map(\.value)`
`20`	`20`	`self.createObserver = { onChange in`
`21`	`21`	`registry.addObserver(nodes: nodes, initial: true, onChange: onChange)`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`init<Wrapped>(alias node: EntityNode<AliasContainer<Wrapped>>, registry: ObserverRegistry)`
`26`	`26`	`where T == Optional<Wrapped> {`
`27`		`- self.init(value: node.ref.value.content) { onChange in`
	`27`	`+ self.init(value: node.value.content) { onChange in`
`28`	`28`	`registry.addObserver(node: node, initial: true, onChange: { container in`
`29`	`29`	`onChange(container.content)`
`30`	`30`	`})`
Original file line number	Diff line number	Diff line change
`@@ -36,15 +36,15 @@ class ObserverRegistry {`
`36`	`36`	/// register an observer to observe changes on an entity node. Everytime `ObserverRegistry` is notified about changes
`37`	`37`	/// to this node `onChange` will be called.
`38`	`38`	`func addObserver<T>(node: EntityNode<T>, key: ObjectKey, initial: Bool = false, onChange: @escaping (T) -> Void) -> Subscription {`
`39`		`- let handler = Handler { onChange($0.ref.value) }`
	`39`	`+ let handler = Handler { onChange($0.value) }`
`40`	`40`
`41`	`41`	`if initial {`
`42`	`42`	`if queue == DispatchQueue.main && Thread.isMainThread {`
`43`		`- onChange(node.ref.value)`
	`43`	`+ onChange(node.value)`
`44`	`44`	`}`
`45`	`45`	`else {`
`46`	`46`	`queue.sync {`
`47`		`- onChange(node.ref.value)`
	`47`	`+ onChange(node.value)`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`}`
`@@ -57,16 +57,16 @@ class ObserverRegistry {`
`57`	`57`	`func addObserver<T>(nodes: [EntityNode<T>], initial: Bool = false, onChange: @escaping ([T]) -> Void) -> Subscription {`
`58`	`58`	`let handler = Handler { (_: EntityNode<T>) in`
`59`	`59`	`// use last value from nodes`
`60`		`- onChange(nodes.map(\.ref.value))`
	`60`	`+ onChange(nodes.map(\.value))`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`if initial {`
`64`	`64`	`if queue == DispatchQueue.main && Thread.isMainThread {`
`65`		`- onChange(nodes.map(\.ref.value))`
	`65`	`+ onChange(nodes.map(\.value))`
`66`	`66`	`}`
`67`	`67`	`else {`
`68`	`68`	`queue.sync {`
`69`		`- onChange(nodes.map(\.ref.value))`
	`69`	`+ onChange(nodes.map(\.value))`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ class ObserverRegistryStub: ObserverRegistry {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`func hasPendingChange<T: Equatable>(for entity: T) -> Bool {`
`16`		`- pendingChangesStub.contains { ($0 as? EntityNode<T>)?.ref.value == entity }`
	`16`	`+ pendingChangesStub.contains { ($0 as? EntityNode<T>)?.value == entity }`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`func hasPendingChange<T>(for _: T.Type) -> Bool {`
`@@ -22,7 +22,7 @@ class ObserverRegistryStub: ObserverRegistry {`
`22`	`22`
`23`	`23`	`/// number of times change has been inserted for this entity`
`24`	`24`	`func pendingChangeCount<T: Equatable>(for entity: T) -> Int {`
`25`		`- pendingChangesStub.filter { ($0 as? EntityNode<T>)?.ref.value == entity }.count`
	`25`	`+ pendingChangesStub.filter { ($0 as? EntityNode<T>)?.value == entity }.count`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`func clearPendingChangesStub() {`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ class AliasStorageTests: XCTestCase {`
`6`	`6`	`var storage: AliasStorage = [:]`
`7`	`7`
`8`	`8`	`XCTAssertNotNil(storage[safe: .testCollection])`
`9`		`- XCTAssertNil(storage[safe: .testCollection].ref.value.content)`
	`9`	`+ XCTAssertNil(storage[safe: .testCollection].value.content)`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`func test_subscriptGet_aliasHasSameNameThanAnotherType_itReturnsAliasContainer() {`
Original file line number	Diff line number	Diff line change
`@@ -30,27 +30,27 @@ class EntityNodeTests: XCTestCase {`
`30`	`30`	`try node.updateEntity(newEntity, modifiedAt: startTimestamp)`
`31`	`31`	`)`
`32`	`32`
`33`		`- XCTAssertEqual(node.value as? RootFixture, startEntity)`
	`33`	`+ XCTAssertEqual(node.value, startEntity)`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`func test_updateEntity_stampIsSup_entityIsUpdated() throws {`
`37`	`37`	`try node.updateEntity(newEntity, modifiedAt: startTimestamp + 1)`
`38`	`38`
`39`		`- XCTAssertEqual(node.value as? RootFixture, newEntity)`
	`39`	`+ XCTAssertEqual(node.value, newEntity)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`func test_updateEntity_stampIsInf_entityIsNotUpdated() throws {`
`43`	`43`	`XCTAssertThrowsError(`
`44`	`44`	`try node.updateEntity(newEntity, modifiedAt: startTimestamp - 1)`
`45`	`45`	`)`
`46`	`46`
`47`		`- XCTAssertEqual(node.value as? RootFixture, startEntity)`
	`47`	`+ XCTAssertEqual(node.value, startEntity)`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`func test_updateEntity_stampIsNil_entityIsUpdated() throws {`
`51`	`51`	`try node.updateEntity(newEntity, modifiedAt: nil)`
`52`	`52`
`53`		`- XCTAssertEqual(node.value as? RootFixture, newEntity)`
	`53`	`+ XCTAssertEqual(node.value, newEntity)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`func test_updateEntity_stampIsNil_stampIsNotUpdated() throws {`
`@@ -94,7 +94,7 @@ class EntityNodeTests: XCTestCase {`
`94`	`94`
`95`	`95`	`node.updateEntityRelationship(childNode)`
`96`	`96`
`97`		`- XCTAssertEqual(node.ref.value.singleNode, newChild)`
	`97`	`+ XCTAssertEqual(node.value.singleNode, newChild)`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`func test_observeChild_childIsCollection_eachChildIsAdded() {`