Merge branch 'improve_redux_action'

sgr-ksmt · Sep 29, 2019 · 310be4e · 310be4e
2 parents e8e46bc + 1c9c0f7
commit 310be4e
Show file tree

Hide file tree

Showing 9 changed files with 48 additions and 75 deletions.
diff --git a/FireTodo/Firebase/Task.swift b/FireTodo/Firebase/Task.swift
@@ -7,7 +7,7 @@ import FireSnapshot
 import SwiftUI
 
 extension Model {
-    struct Task: Codable, HasTimestamps, Equatable {
+    struct Task: HasTimestamps, Codable, Equatable{
         var title: String = ""
         var desc: String = ""
         var completed: Bool = false

diff --git a/FireTodo/Redux/Auth/AuthAction.swift b/FireTodo/Redux/Auth/AuthAction.swift
@@ -11,10 +11,7 @@ import ReSwiftThunk
 
 enum AuthAction: Action {
     case finishInitialLoad
-    case registerAuthChangeHandle(listenerHandle: AuthStateDidChangeListenerHandle)
-    case removeAuthChangeHandle
-    case subscribeAuthChange(cancellable: AnyCancellable)
-    case unsubscribeAuthChange
+    case updateAuthChangeListener(listener: AnyCancellable?)
     case updateUser(user: Snapshot<Model.User>?)
 
     static func subscribe() -> AppThunkAction {
@@ -39,14 +36,14 @@ enum AuthAction: Action {
                 }
                 .sink(receiveValue: dispatch)
 
-            dispatch(AuthAction.subscribeAuthChange(cancellable: cancellable))
+            dispatch(AuthAction.updateAuthChangeListener(listener: cancellable))
         }
     }
 
     static func unsubscribe() -> AppThunkAction {
         AppThunkAction { dispatch, getState in
             getState()?.authState.listenerCancellable?.cancel()
-            dispatch(AuthAction.unsubscribeAuthChange)
+            dispatch(AuthAction.updateAuthChangeListener(listener: nil))
         }
     }
 

diff --git a/FireTodo/Redux/Auth/AuthReducer.swift b/FireTodo/Redux/Auth/AuthReducer.swift
@@ -9,32 +9,20 @@ enum AuthReducer {
     static var reduce: Reducer<AuthState> {
         return { action, state in
             var state = state ?? AuthState()
+            guard let action = action as? AuthAction else {
+                return state
+            }
             switch action {
-            case let action as AuthAction:
-                switch action {
-                case .finishInitialLoad:
-                    state.loadingState = .loaded
-                    return state
-                case let .registerAuthChangeHandle(listenerHandle):
-                    state.listenerHandle = listenerHandle
-                    return state
-                case .removeAuthChangeHandle:
-                    state.listenerHandle = nil
-                    return state
-                case let .subscribeAuthChange(cancellable):
-                    state.listenerCancellable = cancellable
-                    return state
-                case .unsubscribeAuthChange:
-                    state.listenerCancellable = nil
-                    return state
-                case let .updateUser(user):
-                    state.user = user
-                    return state
-                }
-            default:
-                break
+            case .finishInitialLoad:
+                state.loadingState = .loaded
+                return state
+            case let .updateAuthChangeListener(cancellable):
+                state.listenerCancellable = cancellable
+                return state
+            case let .updateUser(user):
+                state.user = user
+                return state
             }
-            return state
         }
     }
 }
diff --git a/FireTodo/Redux/Auth/AuthState.swift b/FireTodo/Redux/Auth/AuthState.swift
@@ -16,6 +16,5 @@ struct AuthState: StateType {
 
     var loadingState: LoadingState = .initial
     var user: Snapshot<Model.User>?
-    var listenerHandle: AuthStateDidChangeListenerHandle?
     var listenerCancellable: AnyCancellable?
 }
diff --git a/FireTodo/Redux/EditTask/EditTaskReducer.swift b/FireTodo/Redux/EditTask/EditTaskReducer.swift
@@ -9,25 +9,22 @@ enum EditTaskReducer {
     static var reduce: Reducer<EditTaskState> {
         return { action, state in
             var state = state ?? EditTaskState()
+            guard let action = action as? EditTaskAction else {
+                return state
+            }
             switch action {
-            case let action as EditTaskAction:
-                switch action {
-                case .startRequest:
-                    state.requesting = true
-                    return state
-                case .endRequest:
-                    state.requesting = false
-                    return state
-                case .closeView:
-                    state.saved = true
-                    return state
-                case .reset:
-                    return EditTaskState()
-                }
-            default:
-                break
+            case .startRequest:
+                state.requesting = true
+                return state
+            case .endRequest:
+                state.requesting = false
+                return state
+            case .closeView:
+                state.saved = true
+                return state
+            case .reset:
+                return EditTaskState()
             }
-            return state
         }
     }
 }
diff --git a/FireTodo/Redux/Main/AppStore.swift b/FireTodo/Redux/Main/AppStore.swift
@@ -9,18 +9,15 @@ import ReSwift
 final class AppStore: StoreSubscriber, DispatchingStoreType, ObservableObject {
     private let store: Store<AppState>
     var state: AppState { store.state }
-    private let stateChange = ObservableObjectPublisher()
-    var objectWillChange: ObservableObjectPublisher {
-        stateChange
-    }
+    private(set) var objectWillChange: ObservableObjectPublisher = .init()
 
     init(_ store: Store<AppState>) {
         self.store = store
         store.subscribe(self)
     }
 
     func newState(state: AppState) {
-        stateChange.send()
+        objectWillChange.send()
     }
 
     func dispatch(_ action: Action) {

diff --git a/FireTodo/Redux/Middleware/Logging/LoggingMiddleware.swift b/FireTodo/Redux/Middleware/Logging/LoggingMiddleware.swift
@@ -9,7 +9,7 @@ func createLoggingMiddleware() -> Middleware<AppState> {
     return { _, _ in
         { next in
             { action in
-                print(">  \(action)")
+                print("[dispatch]: \(action)")
                 next(action)
             }
         }

diff --git a/FireTodo/Redux/Tasks/TasksAction.swift b/FireTodo/Redux/Tasks/TasksAction.swift
@@ -9,12 +9,13 @@ import ReSwift
 
 enum TasksAction: Action {
     case updateTasks(tasks: [Snapshot<Model.Task>])
-    case registerListener(listener: ListenerRegistration)
-    case removeListener
+    case updateListener(listener: ListenerRegistration?)
 
     static func subscribe(userID: String) -> AppThunkAction {
         AppThunkAction { dispatch, _ in
-            let listener = Snapshot<Model.Task>.listen(Model.Path.tasks(userID: userID)) { result in
+            let listener = Snapshot<Model.Task>.listen(Model.Path.tasks(userID: userID), queryBuilder: {
+                $0.order(by: "updateTime", descending: true).limit(to: 30)
+            }) { result in
                 switch result {
                 case let .success(tasks):
                     dispatch(TasksAction.updateTasks(tasks: tasks))
@@ -24,14 +25,14 @@ enum TasksAction: Action {
                     dispatch(TasksAction.updateTasks(tasks: []))
                 }
             }
-            dispatch(TasksAction.registerListener(listener: listener))
+            dispatch(TasksAction.updateListener(listener: listener))
         }
     }
 
     static func unsubscribe() -> AppThunkAction {
         AppThunkAction { dispatch, getState in
             getState()?.tasksState.tasksListener?.remove()
-            dispatch(TasksAction.removeListener)
+            dispatch(TasksAction.updateListener(listener: nil))
         }
     }
 

diff --git a/FireTodo/Redux/Tasks/TasksReducer.swift b/FireTodo/Redux/Tasks/TasksReducer.swift
@@ -9,23 +9,17 @@ enum TasksReducer {
     static var reduce: Reducer<TasksState> {
         return { action, state in
             var state = state ?? TasksState()
+            guard let action = action as? TasksAction else {
+                return state
+            }
             switch action {
-            case let action as TasksAction:
-                switch action {
-                case let .updateTasks(tasks):
-                    state.tasks = tasks
-                    return state
-                case let .registerListener(listener):
-                    state.tasksListener = listener
-                    return state
-                case .removeListener:
-                    state.tasksListener = nil
-                    return state
-                }
-            default:
-                break
+            case let .updateTasks(tasks):
+                state.tasks = tasks
+                return state
+            case let .updateListener(listener):
+                state.tasksListener = listener
+                return state
             }
-            return state
         }
     }
 }