Add POC for LocationCacheStore

Author: 0xLeif

Package.resolved

@@ -5,24 +5,32 @@ import PackageDescription
 
 let package = Package(
     name: "LocationCacheStore",
+    platforms: [
+        .iOS(.v14),
+        .macOS(.v11),
+        .watchOS(.v7)
+    ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(
             name: "LocationCacheStore",
-            targets: ["LocationCacheStore"]),
+            targets: ["LocationCacheStore"]
+        )
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.
-        // .package(url: /* package url */, from: "1.0.0"),
+         .package(url: "https://github.com/0xOpenBytes/CacheStore", from: "3.2.0")
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages this package depends on.
         .target(
             name: "LocationCacheStore",
-            dependencies: []),
+            dependencies: ["CacheStore"]
+        ),
         .testTarget(
             name: "LocationCacheStoreTests",
-            dependencies: ["LocationCacheStore"]),
+            dependencies: ["LocationCacheStore"]
+        )
     ]
 )

Package.swift

@@ -1,3 +1,3 @@
 # LocationCacheStore
 
-A description of this package.
+## 🚧

README.md

@@ -0,0 +1,108 @@
+import CacheStore
+import CoreLocation
+
+/// `LocationStore` Keys
+///     - location: CLLocation
+public enum LocationStoreKey {
+    case location // CLLocation
+}
+
+/// `LocationStore` Actions
+public enum LocationStoreAction {
+    case updateLocation
+    case locationUpdated(CLLocation?)
+}
+
+/// `LocationStore` Dependency
+public struct LocationStoreDependency {
+    var updateLocation: () async -> CLLocation?
+}
+
+public extension LocationStoreDependency {
+    /// Mock Dependency
+    static func mock(location: CLLocation) -> LocationStoreDependency {
+        LocationStoreDependency(
+            updateLocation: { location }
+        )
+    }
+    
+    /// Live Dependency using CLLocationManager and requestWhenInUseAuthorization if authorizationStatus == .notDetermined
+    static var live: LocationStoreDependency {
+        LocationStoreDependency(
+            updateLocation: {
+                let locationManager = CLLocationManager()
+                
+                if locationManager.authorizationStatus == .notDetermined {
+                    locationManager.requestWhenInUseAuthorization()
+                }
+                
+                return locationManager.location
+            }
+        )
+    }
+}
+
+/// Higher-order StoreActionHandler
+public func locationStoreActionHandler(
+    withActionHandler actionHandler: StoreActionHandler<LocationStoreKey, LocationStoreAction, LocationStoreDependency>? = nil
+) -> StoreActionHandler<LocationStoreKey, LocationStoreAction, LocationStoreDependency> {
+    StoreActionHandler<LocationStoreKey, LocationStoreAction, LocationStoreDependency> { cacheStore, action, dependency in
+        switch action {
+        case .updateLocation:
+            struct UpdateLocationActionEffectID: Hashable { }
+            
+            return ActionEffect(id: UpdateLocationActionEffectID()) {
+                .locationUpdated(await dependency.updateLocation())
+            }
+            
+        case let .locationUpdated(location):
+            cacheStore.set(value: location, forKey: .location)
+        }
+        
+        guard
+            let actionHandler = actionHandler,
+            let nextAction = actionHandler.handle(store: &cacheStore, action: action, dependency: dependency)
+        else {
+            struct RepeatUpdateLocationActionEffectID: Hashable { }
+            
+            return ActionEffect(id: RepeatUpdateLocationActionEffectID()) {
+                sleep(1)
+                return .updateLocation
+            }
+        }
+        
+        return nextAction
+    }
+}
+
+/// LocationStore that updates the user's location
+public class LocationStore: Store<LocationStoreKey, LocationStoreAction, LocationStoreDependency> {
+    /// Create a LocationStore with an ActionHandler and Dependency
+    public init(
+        withActionHandler actionHandler: StoreActionHandler<LocationStoreKey, LocationStoreAction, LocationStoreDependency>? = nil,
+        dependency: LocationStoreDependency = .live
+    ) {
+        super.init(
+            initialValues: [:],
+            actionHandler: locationStoreActionHandler(withActionHandler: actionHandler),
+            dependency: dependency
+        )
+        
+        handle(action: .updateLocation)
+    }
+    
+    /// Create a LocationStore using the Store init
+    public required init(
+        initialValues: [LocationStoreKey: Any],
+        actionHandler: StoreActionHandler<LocationStoreKey, LocationStoreAction, LocationStoreDependency>,
+        dependency: LocationStoreDependency
+    ) {
+        super.init(
+            initialValues: initialValues,
+            actionHandler: locationStoreActionHandler(withActionHandler: actionHandler),
+            dependency: dependency
+        )
+        
+        handle(action: .updateLocation)
+    }
+}

Sources/LocationCacheStore/LocationCacheStore.swift

@@ -1,11 +1,65 @@
+import CacheStore
+import CoreLocation
+import t
 import XCTest
 @testable import LocationCacheStore
 
 final class LocationCacheStoreTests: XCTestCase {
     func testExample() throws {
-        // This is an example of a functional test case.
-        // Use XCTAssert and related functions to verify your tests produce the correct
-        // results.
-        XCTAssertEqual(LocationCacheStore().text, "Hello, World!")
+        let initLocation = CLLocation()
+        
+        let locationStore = LocationStore(
+            initialValues: [:],
+            actionHandler: locationStoreActionHandler(),
+            dependency: .mock(location: initLocation)
+        )
+        
+        enum ExampleKey {
+            case location
+        }
+        
+        struct ExampleStoreContent: StoreContent {
+            var store: Store<ExampleKey, Void, Void>
+            
+            var location: CLLocation {
+                store.resolve(.location)
+            }
+        }
+        
+        var exampleStore: TestStore<ExampleKey, Void, Void> {
+            TestStore(
+                store: locationStore.actionlessScope(
+                    keyTransformation: (
+                        from: { parent in
+                            switch parent {
+                            case .location: return .location
+                            default: return nil
+                            }
+                        },
+                        to: { child in
+                            switch child {
+                            case .location: return .location
+                            default: return nil
+                            }
+                        }
+                    ),
+                    dependencyTransformation: { _ in () }
+                )
+            )
+        }
+        
+        // MARK: - Test
+        exampleStore.content { (content: ExampleStoreContent) in
+            try t.assert(content.location.coordinate.latitude, isEqualTo: initLocation.coordinate.latitude)
+            try t.assert(content.location.coordinate.latitude, isEqualTo: initLocation.coordinate.latitude)
+        }
+        
+        let newLocation = CLLocation(latitude: 1, longitude: 1)
+        locationStore.handle(action: .locationUpdated(newLocation))
+        
+        exampleStore.content { (content: ExampleStoreContent) in
+            try t.assert(content.location.coordinate.latitude, isEqualTo: newLocation.coordinate.latitude)
+            try t.assert(content.location.coordinate.latitude, isEqualTo: newLocation.coordinate.latitude)
+        }
     }
 }