fix(collection): Fixed assign not working with custom collection (#41)

pjechris · May 19, 2023 · 8ec5720 · 8ec5720
1 parent 71cf0df
commit 8ec5720
Show file tree

Hide file tree

Showing 9 changed files with 111 additions and 51 deletions.
diff --git a/Sources/CohesionKit/KeyPath/PartialIdentifiableKeyPath.swift b/Sources/CohesionKit/KeyPath/PartialIdentifiableKeyPath.swift
@@ -45,7 45,7 @@ public struct PartialIdentifiableKeyPath<Root> {
  }
  }
 
- public init<C: MutableCollection>(_ keyPath: KeyPath<Root, C>) where C.Element: Identifiable, C.Index: Hashable {
  public init<C: BufferedCollection>(_ keyPath: KeyPath<Root, C>) where C.Element: Identifiable, C.Index: Hashable {
  self.keyPath = keyPath
  self.accept = { parent, root, stamp, visitor in
  visitor.visit(
@@ -55,7 55,7 @@ public struct PartialIdentifiableKeyPath<Root> {
  }
  }
 
- public init<C: MutableCollection>(_ keyPath: KeyPath<Root, C>) where C.Element: Aggregate, C.Index: Hashable {
  public init<C: BufferedCollection>(_ keyPath: KeyPath<Root, C>) where C.Element: Aggregate, C.Index: Hashable {
  self.keyPath = keyPath
  self.accept = { parent, root, stamp, visitor in
  visitor.visit(

diff --git a/Sources/CohesionKit/Storage/EntityNode.swift b/Sources/CohesionKit/Storage/EntityNode.swift
@@ -60,7 60,7 @@ class EntityNode<T>: AnyEntityNode {
  }
 
  /// observe one of the node child whose type is a collection
- func observeChild<C: MutableCollection>(_ childNode: EntityNode<C.Element>, for keyPath: KeyPath<T, C>, index: C.Index)
  func observeChild<C: BufferedCollection>(_ childNode: EntityNode<C.Element>, for keyPath: KeyPath<T, C>, index: C.Index)
  where C.Index: Hashable {
  observeChild(childNode, identity: keyPath.appending(path: \C[index])) { pointer, newValue in
  pointer.assign(newValue, to: keyPath, index: index)

diff --git a/Sources/CohesionKit/UnsafePointer/BufferedCollection.swift b/Sources/CohesionKit/UnsafePointer/BufferedCollection.swift
@@ -0,0 1,14 @@
 import Foundation
 
 /// A collection providing an access to its buffer.
 /// 
 /// Idea was to directly use `BufferedCollection.withContiguousStorageIfAvailable`` **but default implementation returns nil**
 /// (see https://github.com/apple/swift-evolution/blob/main/proposals/0237-contiguous-collection.md)
 public protocol BufferedCollection: Collection {
  /// Provides an access to collection inner buffer.
  /// 
  /// Don't forward to `withContiguousStorageIfAvailable` which default implementation returns nil 🤦‍♂️
  mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
 }
 
 extension Array: BufferedCollection { }
diff --git a/...eyPath/UnsafeMutablePointer KeyPath.swift → ...ointer/UnsafeMutablePointer KeyPath.swift b/...eyPath/UnsafeMutablePointer KeyPath.swift → ...ointer/UnsafeMutablePointer KeyPath.swift
@@ -11,7 11,7 @@ extension UnsafeMutablePointer {
  unsafeValuePointer.pointee = value
  }
 
- func assign<C: MutableCollection>(_ value: C.Element, to keyPath: KeyPath<Pointee, C>, index: C.Index) {
  func assign<C: BufferedCollection>(_ value: C.Element, to keyPath: KeyPath<Pointee, C>, index: C.Index) {
 
  guard let unsafeCollectionPointer = UnsafeMutablePointer<C>(mutating: pointer(to: keyPath)) else {
  fatalError("cannot update value for KeyPath<\(Pointee.self), \(C.self)>: failed to access memory pointer.")
@@ -22,6 22,6 @@ extension UnsafeMutablePointer {
  .pointee
  .distance(from: unsafeCollectionPointer.pointee.startIndex, to: index)
 
- unsafeCollectionPointer.pointee.withContiguousMutableStorageIfAvailable { $0[distance] = value }
  unsafeCollectionPointer.pointee.withUnsafeMutableBufferPointer { $0[distance] = value }
  }
 }
diff --git a/Sources/CohesionKit/Visitor/IdentityMapStoreVisitor.swift b/Sources/CohesionKit/Visitor/IdentityMapStoreVisitor.swift
@@ -32,7 32,7 @@ struct IdentityMapStoreVisitor: NestedEntitiesVisitor {
  }
  }
 
- func visit<Root, C: MutableCollection>(context: EntityContext<Root, C>, entities: C)
  func visit<Root, C: BufferedCollection>(context: EntityContext<Root, C>, entities: C)
  where C.Element: Identifiable, C.Index: Hashable {
 
  for index in entities.indices {
@@ -44,7 44,7 @@ struct IdentityMapStoreVisitor: NestedEntitiesVisitor {
  }
  }
 
- func visit<Root, C: MutableCollection>(context: EntityContext<Root, C>, entities: C)
  func visit<Root, C: BufferedCollection>(context: EntityContext<Root, C>, entities: C)
  where C.Element: Aggregate, C.Index: Hashable {
 
  for index in entities.indices {

diff --git a/Sources/CohesionKit/Visitor/NestedEntitiesVisitor.swift b/Sources/CohesionKit/Visitor/NestedEntitiesVisitor.swift
@@ -8,9 8,9 @@ protocol NestedEntitiesVisitor {
  func visit<Root, T: Identifiable>(context: EntityContext<Root, T?>, entity: T?)
  func visit<Root, T: Aggregate>(context: EntityContext<Root, T?>, entity: T?)
 
- func visit<Root, C: MutableCollection>(context: EntityContext<Root, C>, entities: C)
  func visit<Root, C: BufferedCollection>(context: EntityContext<Root, C>, entities: C)
  where C.Element: Identifiable, C.Index: Hashable
 
- func visit<Root, C: MutableCollection>(context: EntityContext<Root, C>, entities: C)
  func visit<Root, C: BufferedCollection>(context: EntityContext<Root, C>, entities: C)
  where C.Element: Aggregate, C.Index: Hashable
 }
diff --git a/Tests/CohesionKitTests/KeyPath/UnsafeMutablePointerTests.swift b/Tests/CohesionKitTests/KeyPath/UnsafeMutablePointerTests.swift
diff --git a/Tests/CohesionKitTests/UnsafePointer/UnsafeMutablePointerTests.swift b/Tests/CohesionKitTests/UnsafePointer/UnsafeMutablePointerTests.swift
@@ -0,0 1,87 @@
 import XCTest
 @testable import CohesionKit
 
 class UnsafeMutablePointerTests: XCTestCase {
  func test_assign_propertyIsImmutable_propertyIsChanged() {
  var hello = Hello(collection: [], singleValue: "hello")
 
  withUnsafeMutablePointer(to: &hello) {
  $0.assign("world", to: \Hello.singleValue)
  }
 
  XCTAssertEqual(hello.singleValue, "world")
  }
 
  func test_assign_keyPathIsArray_propertyIsImmutable_arrayIsChanged() {
  var hello = Hello(collection: [1, 2, 3, 4], singleValue: "")
 
  withUnsafeMutablePointer(to: &hello) {
  $0.assign(5, to: \Hello.collection, index: 3)
  }
 
  XCTAssertEqual(hello.collection, [1, 2, 3, 5])
  }
 
  func test_assign_keyPathIsArray_mutipleAssignments_arrayIsChanged() {
  var hello = Hello(collection: [1, 2, 3, 4], singleValue: "")
 
  withUnsafeMutablePointer(to: &hello) {
  $0.assign(4, to: \Hello.collection, index: 0)
  $0.assign(3, to: \Hello.collection, index: 0)
  $0.assign(2, to: \Hello.collection, index: 0)
  }
 
  XCTAssertEqual(hello.collection, [2, 2, 3, 4])
  }
 
  func test_assign_keyPathIsCustomCollection_colectionIsChanged() {
  var hello = Hello(collection: [], singleValue: "")
 
  hello.myCollection = ["1", "2"]
 
  withUnsafeMutablePointer(to: &hello) {
  $0.assign("3", to: \.myCollection, index: 0)
  $0.assign("4", to: \.myCollection, index: 1)
  }
 
  XCTAssertEqual(hello.myCollection, ["3", "4"])
  }
 }
 
 private struct Hello {
  let collection: [Int]
  let singleValue: String
  var myCollection: MyCollection = []
 }
 
 struct MyCollection: BufferedCollection, Equatable, ExpressibleByArrayLiteral {
  typealias Element = Array<String>.Element
  typealias Index = Array<String>.Index
 
  var elements: [String] = []
 
  var startIndex: Index { elements.startIndex }
 
  var endIndex: Index { elements.endIndex }
 
  init(arrayLiteral elements: String...) {
  self.elements = elements
  }
 
  subscript(position: Index) -> Element {
  get {
  elements[position]
  }
  set(newValue) {
  elements[position] = newValue
  }
  }
 
  func index(after i: Index) -> Index {
  elements.index(after: i)
  }
 
  mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R {
  try elements.withUnsafeMutableBufferPointer(body)
  }
 }
diff --git a/Tests/CohesionKitTests/Visitor/IdentityMapStoreVisitorTests.swift b/Tests/CohesionKitTests/Visitor/IdentityMapStoreVisitorTests.swift
@@ -60,7 60,7 @@ private class EntityNodeStub<T>: EntityNode<T> {
  var observeChildKeyPathIndexCalled: (AnyEntityNode, PartialKeyPath<T>, Any) -> Void = { _, _, _ in }
  var observeChildKeyPathOptionalCalled: (AnyEntityNode, PartialKeyPath<T>) -> Void = { _, _ in }
 
- override func observeChild<C: MutableCollection>(
  override func observeChild<C: BufferedCollection>(
  _ childNode: EntityNode<C.Element>,
  for keyPath: KeyPath<T, C>,
  index: C.Index