Simpler bindings (#81)

* Remove the ValueBinding type and use the built in Binding type

* Add comments

* Make `current` on `ObservableValue` `Published`

* Lint fix

* Lint fix

* Update documentation

* Update docs script

Author: MortenGregersen

.gitignore

@@ -3,3 +3,4 @@
 /Packages
 /*.xcodeproj
 xcuserdata/
+docs

Documentation/Abstracts/Test Support.md

@@ -35,7 +35,7 @@ The `MockStore` can be used to override `Selector`s so that they always return a
 import FluxorTestSupport
 import XCTest
 
-class GreetingView: XCTestCase {
+class GreetingViewTests: XCTestCase {
     func testGreeting() {
         let greeting = "Hi Bob!"
         let mockStore = MockStore(initialState: AppState(greeting: "Hi Steve!"))
@@ -48,13 +48,15 @@ class GreetingView: XCTestCase {
 
 ## Intercepting state changes
 
+**NOTE:** This is built into the `MockStore`.
+
 The `TestInterceptor` can be registered on the `Store`. When registered it gets all `Action`s dispatched and state changes. Everything it intercepts gets saved in an array in the order received. This can be used to assert which `Action`s are dispatched in a test.
 
 ```swift
 import FluxorTestSupport
 import XCTest
 
-class GreetingView: XCTestCase {
+class GreetingViewTests: XCTestCase {
     func testGreeting() {
         let testInterceptor = TestInterceptor<AppState>()
         let store = Store(initialState: AppState())

Documentation/Abstracts/Using Fluxor with SwiftUI.md

@@ -20,24 +20,24 @@ struct DrawView: View {
 
 ## Binding a value which can be changed
 
-The `ValueBinding` can be used to create a [`Binding`](https://developer.apple.com/documentation/swiftui/binding) to a value in the `State` and use an `ActionTemplate` to update the value through the `Store`. The `binding` property on `ValueBinding` will create a [`Binding`](https://developer.apple.com/documentation/swiftui/binding) which can be used like any other bindings. The value can also manually be updated using the `update` function. This will dispatch an `Action` on the `Store` based on the specified `ActionTemplate`.
+The `Store` is extended with functions to create [`Bindings`](https://developer.apple.com/documentation/swiftui/binding) to a value in the `State` and use an `ActionTemplate` to update the value through the `Store`. The [`Binding`](https://developer.apple.com/documentation/swiftui/binding) can be used like any other bindings. When the value in the [`Binding`](https://developer.apple.com/documentation/swiftui/binding) is changed an `Action` will be dispatched on the `Store` based on the specified `ActionTemplate`.
 
 ```swift
 import FluxorSwiftUI
 import SwiftUI
 
 struct GreetingView: View {
-    var greeting = Current.store.binding(get: Selectors.getGreeting, send: Actions.setGreeting)
+    var greeting: Binding<String> = Current.store.binding(get: Selectors.getGreeting, send: Actions.setGreeting)
 
     var body: some View {
-        TextField("Greeting", text: greeting.binding)
+        TextField("Greeting", text: greeting)
     }
 }
 ```
 
 ## Binding a value which can be enabled and disabled
 
-When the `ValueBinding` has a `Bool` value, it can be created with a `ActionTemplate` for enabling the value (making it `true`) and another one for disabling the value (making it `false`). When the value is `Bool` and the payload for the `ActionTemplate` is either `Void` or `Bool`, the `ValueBinding` gains more functions beside the `update` function to `toggle`, `enable` and `disable` the value.
+When the `Binding` has a `Bool` value, it can be created with a `ActionTemplate` for enabling the value (making it `true`) and another one for disabling the value (making it `false`). When the value is `Bool` and the payload for the `ActionTemplate` is either `Void` or `Bool`, the `ValueBinding` gains more functions beside the `update` function to `toggle`, `enable` and `disable` the value.
 
 ```swift
 import FluxorSwiftUI
@@ -49,8 +49,8 @@ struct DrawView: View {
                                                      disable: Actions.cancelClear)
 
     var body: some View {
-        Button(action: { self.showClearActionSheet.enable() }, label: { Text("Clear") })
-            .actionSheet(isPresented: showClearActionSheet.binding) { clearActionSheet }
+        Button(action: { Current.store.dispatch(action: Actions.askToClear() }, label: { Text("Clear") })
+            .actionSheet(isPresented: showClearActionSheet) { clearActionSheet }
     }
 
     private var clearActionSheet: ActionSheet {

Documentation/generate_docs.sh

@@ -1,6 +1,7 @@
 rm -rf docs
-sourcekitten doc --spm --module-name Fluxor > mod1.json
-sourcekitten doc --spm --module-name FluxorTestSupport > mod2.json
-sourcekitten doc --spm --module-name FluxorSwiftUI > mod3.json
-jazzy --sourcekitten-sourcefile mod1.json,mod2.json,mod3.json
+mkdir docs
+sourcekitten doc --spm --module-name Fluxor > docs/mod1.json
+sourcekitten doc --spm --module-name FluxorTestSupport > docs/mod2.json
+sourcekitten doc --spm --module-name FluxorSwiftUI > docs/mod3.json
+jazzy --sourcekitten-sourcefile docs/mod1.json,docs/mod2.json,docs/mod3.json
 open docs/index.html

Package.swift

@@ -40,6 +40,6 @@ let package = Package(
             dependencies: ["Fluxor"]),
         .testTarget(
             name: "FluxorSwiftUITests",
-            dependencies: ["FluxorSwiftUI"]),
+            dependencies: ["FluxorSwiftUI", "FluxorTestSupport"]),
     ]
 )

Sources/FluxorSwiftUI/ObservableValue.swift

@@ -25,7 +25,7 @@ public extension Store {
  */
 public class ObservableValue<Value>: ObservableObject {
     /// The current value. This will change everytime the `State` in the `Store` changes
-    public private(set) var current: Value { willSet { objectWillChange.send() } }
+    @Published public private(set) var current: Value
     private var cancellable: AnyCancellable!
 
     /**

Sources/FluxorSwiftUI/Store+Binding.swift

@@ -0,0 +1,65 @@
+/*
+ * FluxorSwiftUI
+ *  Copyright (c) Morten Bjerg Gregersen 2020
+ *  MIT license, see LICENSE file for details
+ */
+
+import Fluxor
+import SwiftUI
+
+public extension Store {
+    /**
+     Creates a `ValueBinding` from the given `Selector` and `ActionTemplate`.
+
+      When the value is updated an `Action`, created from the `ActionTemplate`, is dispatched on the `Store`.
+
+     - Parameter selector: The `Selector`s to use for getting the current value
+     - Parameter actionTemplate: The `ActionTemplate` to use for dispatching an `Action` when the value changes
+     - Returns: A `Binding` based on the given `Selector` and `ActionTemplate`
+     */
+    func binding<Value>(get selector: Fluxor.Selector<State, Value>,
+                        send actionTemplate: ActionTemplate<Value>) -> Binding<Value> {
+        .init(get: { self.selectCurrent(selector) },
+              set: { self.dispatch(action: actionTemplate.createAction(payload: $0)) })
+    }
+
+    /**
+     Creates a `Binding` from the given `Selector` and `ActionTemplate`s for enabling and disabling the value.
+
+     When the value is enabled/disabled, an `Action`, created from one of the `ActionTemplate`s,
+     is dispatched on the `Store`.
+
+     - Parameter selector: The `Selector`s to use for getting the current value
+     - Parameter enableActionTemplate: The `ActionTemplate` to use for dispatching an `Action`
+                                       when the value should be enabled
+     - Parameter disableActionTemplate: The `ActionTemplate` to use for dispatching an `Action`
+                                        when the value should be disabled
+     - Returns: A `Binding` based on the given `Selector` and `ActionTemplate`s
+     */
+    func binding(get selector: Fluxor.Selector<State, Bool>,
+                 enable enableActionTemplate: ActionTemplate<Void>,
+                 disable disableActionTemplate: ActionTemplate<Void>)
+        -> Binding<Bool> {
+        return .init(get: { self.selectCurrent(selector) },
+                     set: { self.dispatch(action: ($0 ? enableActionTemplate : disableActionTemplate)()) })
+    }
+
+    /**
+     Creates a `Binding` from the given `Selector` and `ActionTemplate`.
+
+      When the value is updated an `Action` (returned by the closure), is dispatched on the `Store`.
+
+     - Parameter selector: The `Selector`s to use for getting the current value
+     - Parameter action: A closure used to decide which `ActionTemplate` to use
+                                 for dispatching an `Action` when the value changes
+     - Parameter value: The value used to decide which `ActionTemplate` to use for the update.
+                        This can either be the current value or the one used for the update
+     - Returns: A `Binding` based on the given `Selector` and `ActionTemplate`
+     */
+    func binding<Value>(get selector: Fluxor.Selector<State, Value>,
+                        send action: @escaping (_ value: Value) -> Action)
+        -> Binding<Value> {
+        return .init(get: { self.selectCurrent(selector) },
+                     set: { self.dispatch(action: action($0)) })
+    }
+}

Sources/FluxorSwiftUI/ValueBinding.swift

@@ -20,10 +20,17 @@ class ObservableValueTests: XCTestCase {
     ])
 
     func testBindingWithOneActionTemplate() {
+        // Given
+        let expectation = XCTestExpectation(description: debugDescription)
         let observableValue = store.observe(counterSelector)
+        let cancellable = observableValue.objectWillChange.sink { expectation.fulfill() }
         XCTAssertEqual(observableValue.current, 42)
+        // When
         store.dispatch(action: increment(payload: 1))
+        // Then
         XCTAssertEqual(observableValue.current, 43)
+        wait(for: [expectation], timeout: 1)
+        XCTAssertNotNil(cancellable)
     }
 }