move to using org.reduxkotlin from maven

Author: Patrick Jackson

common/build.gradle

@@ -34,6 +34,8 @@ kotlin {
                 implementation "io.ktor:ktor-client-logging:$ktorVersion"
                 implementation "com.russhwolf:multiplatform-settings:$multiplatformSettingsVersion"
                 implementation "com.willowtreeapps:fuzzywuzzy-kotlin:0.1.1"
+                implementation "org.reduxkotlin:redux-kotlin:0.2"
+                implementation "org.reduxkotlin:redux-kotlin-thunk:0.2"
 
 
                 implementation "io.ktor:ktor-client-core:$ktorVersion"

common/src/commonMain/kotlin/com/beyondeye/reduks/Thunk.kt

@@ -3,9 +3,9 @@ package com.beyondeye.reduks
 import org.reduxkotlin.Store
 import org.reduxkotlin.StoreSubscriber
 
-class SelectorSubscriberBuilder<S : Any>(val store: Store<S>) {
+class SelectorSubscriberBuilder<S : Any>(val store: Store) {
     val state: S
-        get() = store.getState()
+        get() = store.getState() as S
 
     var withAnyChangeFun: (() -> Unit)? = null
 
@@ -35,12 +35,12 @@ class SelectorSubscriberBuilder<S : Any>(val store: Store<S>) {
  *          }
  *      }
  */
-fun <S : Any> SelectorSubscriberFn(store: Store<S>, selectorSubscriberBuilderInit: SelectorSubscriberBuilder<S>.() -> Unit): StoreSubscriber {
-    val subBuilder = SelectorSubscriberBuilder(store)
+fun <S : Any> SelectorSubscriberFn(store: Store, selectorSubscriberBuilderInit: SelectorSubscriberBuilder<S>.() -> Unit): StoreSubscriber {
+    val subBuilder = SelectorSubscriberBuilder<S>(store)
     subBuilder.selectorSubscriberBuilderInit()
     return {
         subBuilder.selectorList.forEach { entry ->
-            entry.key.onChangeIn(store.getState()) { entry.value(store.getState()) }
+            entry.key.onChangeIn(store.getState() as S) { entry.value(store.getState()) }
         }
         subBuilder.withAnyChangeFun?.invoke()
     }

common/src/commonMain/kotlin/com/beyondeye/reduks/builders.kt

@@ -1,7 +1,6 @@
 package com.willowtreeapps.common
 
 import org.reduxkotlin.createStore
-import com.beyondeye.reduks.createThunkMiddleware
 import org.reduxkotlin.applyMiddleware
 import com.willowtreeapps.common.middleware.*
 import com.willowtreeapps.common.middleware.NavigationMiddleware
@@ -15,6 +14,7 @@ import com.willowtreeapps.common.ui.View
 import com.willowtreeapps.common.util.VibrateUtil
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
+import org.reduxkotlin.thunk
 import kotlin.coroutines.CoroutineContext
 
 class GameEngine(navigator: Navigator,
@@ -28,12 +28,9 @@ class GameEngine(navigator: Navigator,
     private val settingsMiddleware by lazy { SettingsMiddleware(LocalStorageSettingsRepository(userSettings(application)), networkContext) }
 
     val appStore by lazy {
-        createStore(::reducer, AppState.INITIAL_STATE
-                , applyMiddleware(createThunkMiddleware(),
-                        viewEffectsMiddleware::dispatch,
-                        navigationMiddleware::dispatch,
-                        settingsMiddleware::dispatch,
-                        ::loggerMiddleware))
+        createStore(reducer, AppState.INITIAL_STATE, applyMiddleware(thunk,
+                navigationMiddleware::dispatch,
+                settingsMiddleware::dispatch))
     }
 
     init {
@@ -49,7 +46,7 @@ class GameEngine(navigator: Navigator,
     }
 
     val state: AppState
-        get() = appStore.state
+        get() = appStore.state as AppState
 
     fun <T : Presenter<*>> attachView(view: View<T>) = presenterFactory.attachView(view as View<Presenter<*>>)
 

common/src/commonMain/kotlin/com/willowtreeapps/common/GameEngine.kt

@@ -1,8 +1,8 @@
 package com.willowtreeapps.common
 
-import com.beyondeye.reduks.*
 import com.willowtreeapps.common.repo.*
 import kotlinx.coroutines.*
+import org.reduxkotlin.Thunk
 import kotlin.coroutines.CoroutineContext
 
 /**

common/src/commonMain/kotlin/com/willowtreeapps/common/NetworkThunks.kt

@@ -4,76 +4,82 @@ import org.reduxkotlin.ActionTypes
 import com.willowtreeapps.common.Actions.*
 import com.willowtreeapps.common.util.NO_MATCH
 import com.willowtreeapps.common.util.match
+import org.reduxkotlin.castingReducer
 
 /**
  * Reducers and functions used by reducers are in this file.  Functions must be pure functions without
  * side effects.
  */
-fun reducer(state: AppState, action: Any): AppState =
-        when (action) {
-            is ActionTypes.INIT -> { AppState.INITIAL_STATE}
-            is FetchingItemsStartedAction -> state.copy(isLoadingItems = true)
-            is FetchingItemsSuccessAction -> {
-                state.copy(isLoadingItems = false,
-                        items = action.itemsHolder.items,
-                        questionTitle = action.itemsHolder.questionTitle,
-                        questions = action.itemsHolder.questions)
-            }
-            is FetchingItemsFailedAction -> state.copy(isLoadingItems = false, errorLoadingItems = true, errorMsg = action.message)
-            is NamePickedAction -> {
-                val answerName: String?
-                val status = if (state.currentQuestionItem().equalsDisplayName(action.name)) {
-                    answerName = action.name
-                    Question.Status.CORRECT
-                } else {
-                    val correctIndex = state.currentQuestion?.choices?.indexOfFirst { it.id == state.currentQuestion?.itemId }
-                    val matchingIndex = match(action.name, state.currentQuestion!!.choices.map { it.displayName() })
-                    when (matchingIndex) {
-                        NO_MATCH -> {
-                            answerName = null
-                            Question.Status.INCORRECT
-                        }
-                        correctIndex -> {
-                            answerName = state.currentQuestion!!.choices[matchingIndex].displayName()
-                            Question.Status.CORRECT
-                        }
-                        else -> {
-                            answerName = state.currentQuestion!!.choices[matchingIndex].displayName()
-                            Question.Status.INCORRECT
-                        }
+val reducer= castingReducer { state: AppState, action ->
+    when (action) {
+        is ActionTypes.INIT -> {
+            AppState.INITIAL_STATE
+        }
+        is FetchingItemsStartedAction -> state.copy(isLoadingItems = true)
+        is FetchingItemsSuccessAction -> {
+            state.copy(isLoadingItems = false,
+                    items = action.itemsHolder.items,
+                    questionTitle = action.itemsHolder.questionTitle,
+                    questions = action.itemsHolder.questions)
+        }
+        is FetchingItemsFailedAction -> state.copy(isLoadingItems = false, errorLoadingItems = true, errorMsg = action.message)
+        is NamePickedAction -> {
+            val answerName: String?
+            val status = if (state.currentQuestionItem().equalsDisplayName(action.name)) {
+                answerName = action.name
+                Question.Status.CORRECT
+            } else {
+                val correctIndex = state.currentQuestion?.choices?.indexOfFirst { it.id == state.currentQuestion?.itemId }
+                val matchingIndex = match(action.name, state.currentQuestion!!.choices.map { it.displayName() })
+                when (matchingIndex) {
+                    NO_MATCH -> {
+                        answerName = null
+                        Question.Status.INCORRECT
+                    }
+                    correctIndex -> {
+                        answerName = state.currentQuestion!!.choices[matchingIndex].displayName()
+                        Question.Status.CORRECT
+                    }
+                    else -> {
+                        answerName = state.currentQuestion!!.choices[matchingIndex].displayName()
+                        Question.Status.INCORRECT
                     }
                 }
-
-                val newQuestions = state.questions.toMutableList()
-                newQuestions[state.currentQuestionIndex] = newQuestions[state.currentQuestionIndex].copy(answerName = answerName,
-                        status = status,
-                        answerNameInterpretedAs = action.name)
-                state.copy(questions = newQuestions, waitingForNextQuestion = true)
-            }
-            is NextQuestionAction -> state.copy(waitingForNextQuestion = false, currentQuestionIndex = state.currentQuestionIndex + 1)
-            is GameCompleteAction -> state.copy(waitingForNextQuestion = false, currentQuestionIndex = state.currentQuestionIndex + 1)
-            is StartOverAction, is ResetGameStateAction -> AppState.INITIAL_STATE.copy(settings = state.settings)
-            is StartQuestionTimerAction -> state.copy(questionClock = action.initialValue)
-            is DecrementCountDownAction -> state.copy(questionClock = state.questionClock - 1)
-            is TimesUpAction -> {
-                val status = Question.Status.TIMES_UP
-                val newQuestions = state.questions.toMutableList()
-                newQuestions[state.currentQuestionIndex] = newQuestions[state.currentQuestionIndex].copy(answerName = "", status = status)
-                state.copy(questions = newQuestions, waitingForNextQuestion = true, questionClock = -1)
             }
 
-            is ChangeNumQuestionsSettingsAction -> state.copy(settings = state.settings.copy(numQuestions = action.num))
-            is ChangeCategorySettingsAction -> state.copy(settings = state.settings.copy(categoryId = action.categoryId))
-            is ChangeMicrophoneModeSettingsAction -> state.copy(settings = state.settings.copy(microphoneMode = action.enabled))
-            is SettingsLoadedAction -> state.copy(settings = action.settings)
+            val newQuestions = state.questions.toMutableList()
+            newQuestions[state.currentQuestionIndex] = newQuestions[state.currentQuestionIndex].copy(answerName = answerName,
+                    status = status,
+                    answerNameInterpretedAs = action.name)
+            state.copy(questions = newQuestions, waitingForNextQuestion = true)
+        }
+        is NextQuestionAction -> state.copy(waitingForNextQuestion = false, currentQuestionIndex = state.currentQuestionIndex + 1)
+        is GameCompleteAction -> state.copy(waitingForNextQuestion = false, currentQuestionIndex = state.currentQuestionIndex + 1)
+        is StartOverAction, is ResetGameStateAction -> AppState.INITIAL_STATE.copy(settings = state.settings)
+        is StartQuestionTimerAction -> state.copy(questionClock = action.initialValue)
+        is DecrementCountDownAction -> state.copy(questionClock = state.questionClock - 1)
+        is TimesUpAction -> {
+            val status = Question.Status.TIMES_UP
+            val newQuestions = state.questions.toMutableList()
+            newQuestions[state.currentQuestionIndex] = newQuestions[state.currentQuestionIndex].copy(answerName = "", status = status)
+            state.copy(questions = newQuestions, waitingForNextQuestion = true, questionClock = -1)
+        }
+
+        is ChangeNumQuestionsSettingsAction -> state.copy(settings = state.settings.copy(numQuestions = action.num))
+        is ChangeCategorySettingsAction -> state.copy(settings = state.settings.copy(categoryId = action.categoryId))
+        is ChangeMicrophoneModeSettingsAction -> state.copy(settings = state.settings.copy(microphoneMode = action.enabled))
+        is SettingsLoadedAction -> state.copy(settings = action.settings)
 
-            is WillowTreeSignInSuccessAction -> state.copy(settings = state.settings.copy(isWillowTree = true))
-            is WillowTreeSignOutSuccessAction -> state.copy(settings = state.settings.copy(isWillowTree = false))
-            is LoadAllSettingsAction -> {state}
+        is WillowTreeSignInSuccessAction -> state.copy(settings = state.settings.copy(isWillowTree = true))
+        is WillowTreeSignOutSuccessAction -> state.copy(settings = state.settings.copy(isWillowTree = false))
+        is LoadAllSettingsAction -> {
+            state
+        }
 
-            else -> {
-                Logger.d("Action ${action::class.simpleName} not handled")
-                state
-            }
+        else -> {
+            Logger.d("Action ${action::class.simpleName} not handled")
+            state
         }
+    }
+}
 

common/src/commonMain/kotlin/com/willowtreeapps/common/Reducers.kt

@@ -1,7 +1,7 @@
 package com.willowtreeapps.common
 
-import com.beyondeye.reduks.Thunk
 import kotlinx.coroutines.*
+import org.reduxkotlin.Thunk
 import kotlin.coroutines.CoroutineContext
 
 class TimerThunks(private val backgroundContext: CoroutineContext) : CoroutineScope {

common/src/commonMain/kotlin/com/willowtreeapps/common/TimerThunks.kt

@@ -3,9 +3,41 @@ package com.willowtreeapps.common.middleware
 import org.reduxkotlin.GetState
 import com.willowtreeapps.common.AppState
 import com.willowtreeapps.common.Logger
+import org.reduxkotlin.Dispatcher
+import org.reduxkotlin.Middleware
+import org.reduxkotlin.Store
 
-fun loggerMiddleware(getState: GetState<AppState>, nextDispatcher: (Any) -> Any, action: Any): Any {
+fun loggerMiddleware(getState: GetState, nextDispatcher: (Any) -> Any, action: Any): Any {
     val result = nextDispatcher(action)
     Logger.d("DISPATCH action: ${action::class.simpleName}: $action")
     return result
 }
+
+val loggerMiddleware2: Middleware =
+        { store ->
+            { next ->
+                { action ->
+                    {
+                        val result = next(action)
+                        Logger.d("DISPATCH action: ${action::class.simpleName}: $action")
+                        result
+                    }
+                }
+            }
+        }
+
+val loggerMiddleware3 = middleWare { store, next, action ->
+    Logger.d("DISPATCH action: ${action::class.simpleName}: $action")
+    next(action)
+}
+
+fun middleWare(dispatch: (Store, Dispatcher, Any) -> Any): Middleware =
+        { store ->
+            { next ->
+                { action: Any ->
+                    {
+                        dispatch(store, next, action)
+                    }
+                }
+            }
+        }

common/src/commonMain/kotlin/com/willowtreeapps/common/middleware/LoggingMiddleware.kt

@@ -1,20 +1,21 @@
 package com.willowtreeapps.common.middleware
 
-import org.reduxkotlin.GetState
 import com.willowtreeapps.common.Actions
-import com.willowtreeapps.common.AppState
+import org.reduxkotlin.Dispatcher
+import org.reduxkotlin.Store
 
 internal class NavigationMiddleware(private val navigator: Navigator) {
 
-    fun dispatch(getState: GetState<AppState>, nextDispatcher: (Any) -> Any, action: Any): Any {
-        val result = nextDispatcher(action)
-        when (action) {
-            is Actions.FetchingItemsSuccessAction -> navigator.goto(Screen.QUESTION)
-            is Actions.GameCompleteAction -> navigator.goto(Screen.GAME_COMPLETE)
-            is Actions.StartOverAction -> navigator.goto(Screen.START)
-            is Actions.SettingsTappedAction -> navigator.goto(Screen.SETTINGS)
+    fun dispatch(store: Store) = { next: Dispatcher ->
+        { action: Any ->
+            when (action) {
+                is Actions.FetchingItemsSuccessAction -> navigator.goto(Screen.QUESTION)
+                is Actions.GameCompleteAction -> navigator.goto(Screen.GAME_COMPLETE)
+                is Actions.StartOverAction -> navigator.goto(Screen.START)
+                is Actions.SettingsTappedAction -> navigator.goto(Screen.SETTINGS)
+            }
+            next(action)
         }
-        return result
     }
 }
 
@@ -27,4 +28,4 @@ enum class Screen {
 
 interface Navigator {
     fun goto(screen: Screen)
-}
+}