Merge pull request #273 from arkivanov/version-3.0.0

Version 3.0.0

Author: arkivanov

.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Update dependencies
         run: sudo apt-get update
       - name: Install dependencies
@@ -38,7 +38,7 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Set up cache
         uses: actions/cache@v2
         with:

.github/workflows/publish.yml

@@ -29,7 +29,7 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Publish Metadata
         env:
           SONATYPE_REPOSITORY_ID: ${{ needs.create-staging-repository.outputs.repository-id }}
@@ -47,7 +47,7 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Publish on Linux
         env:
           SONATYPE_REPOSITORY_ID: ${{ needs.create-staging-repository.outputs.repository-id }}
@@ -65,7 +65,7 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Publish on macOS
         env:
           SONATYPE_REPOSITORY_ID: ${{ needs.create-staging-repository.outputs.repository-id }}
@@ -95,7 +95,7 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Update dependencies
         run: sudo apt-get update
       - name: Install dependencies
@@ -112,6 +112,6 @@ jobs:
       - name: Install Java
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Check macOS publication
         run: ./gradlew :tools:check-publication:build -Pcheck_publication -Dtargets=IOS,WATCHOS,MACOS_X64

README.md

@@ -48,13 +48,14 @@ Recommended minimum Gradle version is 5.3. Please read first the documentation a
 [metadata publishing mode](https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#experimental-metadata-publishing-mode).
 
 There are a number of modules published to Maven Central:
+
 - `mvikotlin` - core interfaces and functionality (multiplatform)
 - `mvikotlin-main` - the main module with the default `Store` implementation (mutiplatform)
 - `mvikotlin-logging` - logging functionality (mutiplatform)
 - `mvikotlin-timetravel` - time travel feature (mutiplatform)
 - `mvikotlin-extensions-reaktive` - extensions set for Reaktive library (multiplatform)
 - `mvikotlin-extensions-coroutines` - extensions set for coroutines (multiplatform)
-- `keepers` - provides `StateKeeper` and `InstanceKeeper` API for state preservation and objects retaining
+- ~~`keepers` - provides `StateKeeper` and `InstanceKeeper` API for state preservation and objects retaining~~ (deprecated)
 - `rx` - a tiny module with abstractions over rx and coroutines (multiplatform)
 
 Add required modules to your module`s build.gradle file:
@@ -68,14 +69,15 @@ implementation "com.arkivanov.mvikotlin:<module-name>:<version>"
 * Extensions for [Reaktive](https://github.com/badoo/Reaktive) library
 * Extensions for [Coroutines](https://github.com/Kotlin/kotlinx.coroutines)
 * Multithreading friendly (freezable in Kotlin Native if needed)
+* Lifecycle-aware connections (bindins) between inputs and outputs
 * Logging functionality with customizable logger and formatter
 * Time travel feature:
-  * Multiplatform for all supported targets
-  * Plug-and-play UI for Android
-  * Plug-and-play UI for iOS (copy-paste from the sample app)
-  * Export/import events for Android
-  * IDEA and Android Studio [plugin](https://plugins.jetbrains.com/plugin/14241-mvikotlin-time-travel) for Android apps
-  * MacOS [client application](mvikotlin-timetravel-client/app-macos) for iOS and macOS apps
+    * Multiplatform for all supported targets
+    * Plug-and-play UI for Android
+    * Plug-and-play UI for iOS (copy-paste from the sample app)
+    * Export/import events for Android
+    * IntelliJ IDEA and Android Studio [plugin](https://plugins.jetbrains.com/plugin/14241-mvikotlin-time-travel) for Android apps
+    * Desktop [client application](mvikotlin-timetravel-client/app-desktop) for Android, Java and native Apple (iOS, watchOS, tvOS, macOS) apps
 
 ## Documentation
 
@@ -84,7 +86,7 @@ implementation "com.arkivanov.mvikotlin:<module-name>:<version>"
 ## Sample project
 
 The sample project is a todo list with details view.
-* Shared module using Reaktive is [here](sample/todo-reaktive)   
+* Shared module using Reaktive is [here](sample/todo-reaktive)
 * Shared module using coroutines is [here](sample/todo-coroutines)
 * Sample Android application with both Reaktive and coroutines implementations, plus logging and time travel is [here](sample/todo-app-android)
 * Sample iOS application with Reaktive implementation only, plus logging and time travel is [here](sample/todo-app-ios)

build.gradle

@@ -8,11 +8,13 @@ buildscript {
         mavenCentral()
         google()
         maven { url "https://plugins.gradle.org/m2/" }
+        maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:4.2.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
         classpath "gradle.plugin.org.jetbrains.intellij.plugins:gradle-intellij-plugin:0.4.18"
+        classpath "org.jetbrains.compose:compose-gradle-plugin:$composeVersion"
     }
 }
 
@@ -24,6 +26,7 @@ allprojects {
     repositories {
         mavenCentral()
         google()
+        maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
     }
 
     plugins.apply("io.gitlab.arturbosch.detekt")

detekt.yml

@@ -400,7 +400,7 @@ naming:
     active: true
     mustBeFirst: true
   MemberNameEqualsClassName:
-    active: true
+    active: false
     ignoreOverridden: true
   NonBooleanPropertyPrefixedWithIs:
     active: false
@@ -533,7 +533,7 @@ style:
     includeLineWrapping: false
   ForbiddenComment:
     active: true
-    values: ['TODO:', 'FIXME:', 'STOPSHIP:']
+    values: ['FIXME:', 'STOPSHIP:']
     allowedPatterns: ''
   ForbiddenImport:
     active: false
@@ -563,7 +563,7 @@ style:
     active: true
     maxJumpCount: 1
   MagicNumber:
-    active: true
+    active: false
     excludes: ['**/test/**', '**/*Test/**']
     ignoreNumbers: ['-1', '0', '1', '2']
     ignoreHashCodeFunction: true

docs/binding_and_lifecycle.md

@@ -2,7 +2,7 @@
 
 ## Binding
 
-Connecting inputs and outputs sounds like a simple task. And indeed it is. But it can be even easier if you use [Binder](https://github.com/arkivanov/MVIKotlin/blob/master/mvikotlin/src/commonMain/kotlin/com/arkivanov/mvikotlin/core/binder/Binder.kt). It provides just two methods: `start()` and `stop()`. When you call `start()` it connects (subscribes) outputs with inputs. And when you call `stop()` it disconnects (unsubscribes).
+Connecting inputs and outputs sounds like a simple task, and indeed it is. But it can be even easier if you use [Binder](https://github.com/arkivanov/MVIKotlin/blob/master/mvikotlin/src/commonMain/kotlin/com/arkivanov/mvikotlin/core/binder/Binder.kt). It provides just two methods: `start()` and `stop()`. When you call `start()` it connects (subscribes) outputs with inputs. And when you call `stop()` it disconnects (unsubscribes).
 
 ### Creating a Binder
 
@@ -74,14 +74,15 @@ Please note that you must dispose `Stores` at the end of life cycle. In this exa
 
 ## Lifecycle
 
-MVIKotlin provides an abstraction over [Lifecycle](https://github.com/arkivanov/MVIKotlin/blob/master/mvikotlin/src/commonMain/kotlin/com/arkivanov/mvikotlin/core/lifecycle/Lifecycle.kt) states and events. Please take a look at the following diagram:
-![Lifecycle](media/lifecycle.jpg)
+MVIKotlin uses [Essenty](https://github.com/arkivanov/Essenty) library (from the same author), which provides `Lifecycle` -  a multiplatform abstraction for lifecycle states and events. The Essenty's `lifecycle` module is used as `api` dependency, so you don't need to explicitly add it to your project. Please familiarise yourself with Essenty library, especially with the `Lifecycle`.
 
-You can subscribe to `Lifecycle` events and unsubscribe from it. You can convert the [AndroidX Lifecycle](https://developer.android.com/topic/libraries/architecture/lifecycle) to MVIKotlin `Lifecycle` using [asMviLifecycle()](https://github.com/arkivanov/MVIKotlin/blob/master/mvikotlin/src/androidMain/kotlin/com/arkivanov/mvikotlin/core/lifecycle/AndroidLifecycleExt.kt) extension function. Also there is [LifecycleRegistry](https://github.com/arkivanov/MVIKotlin/blob/master/mvikotlin/src/commonMain/kotlin/com/arkivanov/mvikotlin/core/lifecycle/LifecycleRegistry.kt) which implements both the `Lifecycle` and `Lifecycle.Callbacks` interfaces, so you can manually control it.
+<img src="media/lifecycle.jpg" width="512">
 
 ## Binder + Lifecycle
 
-Work with the `Binder` can be simplified if you use the `Lifecycle`. Let's simplify our previous binding example::
+Work with the `Binder` can be simplified if you use the `Lifecycle`. You need to add one of the extension modules in order to use `Binder` with `Lifecycle`, either `mvikotlin-extensions-reaktive` or `mvikotlin-extensions-coroutines`.
+
+Let's simplify our previous binding example::
 
 ```kotlin
 class CalculatorController(lifecycle: Lifecycle) {

docs/index.md

@@ -6,7 +6,7 @@ Overview | [Store](store.md) | [View](view.md) | [Binding and Lifecycle](binding
 
 MVI stands for Model-View-Intent. It is an architectural pattern that utilizes unidirectional data flow. The data circulates between `Model` and `View` only in one direction - from `Model` to `View` and from `View` to `Model`.
 
-![MVI](media/mvi.jpg)
+<img src="media/mvi.jpg" width="256">
 
 ### What is MVIKotlin
 
@@ -17,7 +17,7 @@ MVIKotlin does not bring or enforce any particular architecture. Its responsibil
 
 - To provide a single source of truth for `State` (the scope is not defined, it can be a whole app, a screen, a feature, or a part of a feature);
 - To provide an abstraction for UI with efficient updates (however this is not obligatory, you can use whatever you want);
-- To provide lifecycle aware connections (binding) between inputs and outputs (again this is not obligatory in any way).
+- To provide lifecycle-aware connections (binding) between inputs and outputs (again this is not obligatory in any way).
 
 Everything else is out of scope of the library, there are no definitions for "screens", "features", "modules", etc. Also, no particular reactive framework is enforced/exposed. This gives a lot of flexibility:
 
@@ -32,12 +32,13 @@ You can find one of the architecture options in the [samples](https://github.com
 There are two core components in MVIKotlin: 
 
 - `Store` - represents `Model` from MVI, this is the place for business logic
-- `MviView` - represents `View` from MVI, the UI part
+- `MviView` - represents `View` from MVI, the UI part, optional
 
 ### How the data flows
 
 Please take a look at the following diagram:
-![MVIKotlin](media/mvikotlin.jpg)
+
+<img src="media/mvikotlin.jpg" width="384">
 
 The `Store` produces a stream of `States` which is transformed to a stream of `View Models` by a `Mapper` function (f). The `View` renders `View Models` and produces a stream of `View Events` which is transformed to a stream of `Intents` by another `Mapper` function (f). This makes the `Store` and the `View` independent from each other. You can also combine multiple `States` (multiple `Stores`) into a single `View Model` (single `View`), or multiple `View Events` (multiple `Views`) into a single `Intent` (single `Store`). But if you have only one `Store` and only one `View` and you need simplicity then your `View` can directly render `States` and produce `Intents`.
 
@@ -51,7 +52,6 @@ The data flows between core components only on Main thread.
 
 MVI loves reactivity, it's all about data streams and transformations. MVIKotlin is a reactive framework. But the main functionality of the framework does not depend on any such library. A tiny abstraction over Rx is used instead. Extensions for [Reaktive](https://github.com/badoo/Reaktive) and for [Coroutines](https://github.com/Kotlin/kotlinx.coroutines) libraries are provided as separate modules.
 
-
 ### Kotlin/Native
 
 MVIKotlin is Kotlin/Native friendly and supports its tricky memory model (please read about Kotlin/Native [concurrency](https://kotlinlang.org/docs/reference/native/concurrency.html) and [immutability](https://kotlinlang.org/docs/reference/native/immutability.html) if you are unsure).