├── android
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   └── .gitcreate
    │   │   ├── AndroidManifest.xml
    │   │   └── kotlin
    │   │   │   └── org
    │   │   │       └── rewedigital
    │   │   │           └── katana
    │   │   │               └── android
    │   │   │                   ├── AndroidKatanaLogger.kt
    │   │   │                   ├── fragment
    │   │   │                       ├── KatanaFragment.kt
    │   │   │                       └── KatanaFragmentDelegate.kt
    │   │   │                   ├── environment
    │   │   │                       └── AndroidEnvironmentContext.kt
    │   │   │                   └── modules
    │   │   │                       └── AndroidModules.kt
    │   └── test
    │   │   └── kotlin
    │   │       └── .gitcreate
    ├── proguard-consumer-rules.pro
    ├── build.gradle.kts
    └── README.md
├── androidx-fragment
    ├── src
    │   └── main
    │   │   ├── res
    │   │       └── .gitcreate
    │   │   ├── AndroidManifest.xml
    │   │   └── kotlin
    │   │       └── org
    │   │           └── rewedigital
    │   │               └── katana
    │   │                   └── androidx
    │   │                       └── fragment
    │   │                           └── KatanaFragmentFactory.kt
    ├── build.gradle.kts
    └── README.md
├── androidx-viewmodel
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   └── .gitcreate
    │   │   ├── AndroidManifest.xml
    │   │   └── kotlin
    │   │   │   └── org
    │   │   │       └── rewedigital
    │   │   │           └── katana
    │   │   │               └── androidx
    │   │   │                   └── viewmodel
    │   │   │                       ├── internal
    │   │   │                           └── Utils.kt
    │   │   │                       └── ViewModel.kt
    │   └── test
    │   │   └── kotlin
    │   │       └── .gitcreate
    ├── proguard-consumer-rules.pro
    ├── build.gradle.kts
    └── README.md
├── androidx-viewmodel-savedstate
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   └── .gitcreate
    │   │   ├── AndroidManifest.xml
    │   │   └── kotlin
    │   │   │   └── org
    │   │   │       └── rewedigital
    │   │   │           └── katana
    │   │   │               └── androidx
    │   │   │                   └── viewmodel
    │   │   │                       └── savedstate
    │   │   │                           └── ViewModelSavedState.kt
    │   └── test
    │   │   └── kotlin
    │   │       └── .gitcreate
    ├── proguard-consumer-rules.pro
    ├── build.gradle.kts
    └── README.md
├── proguard-rules.pro
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── .gitignore
├── android-example
    ├── src
    │   ├── main
    │   │   ├── ic_launcher-web.png
    │   │   ├── res
    │   │   │   ├── mipmap-hdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-mdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xxhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xxxhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── values
    │   │   │   │   ├── styles.xml
    │   │   │   │   ├── strings.xml
    │   │   │   │   └── main_strings.xml
    │   │   │   ├── mipmap-anydpi-v26
    │   │   │   │   ├── ic_launcher.xml
    │   │   │   │   └── ic_launcher_round.xml
    │   │   │   ├── layout
    │   │   │   │   ├── fragment_first.xml
    │   │   │   │   ├── dialog_remote.xml
    │   │   │   │   ├── activity_main.xml
    │   │   │   │   ├── activity_fragment.xml
    │   │   │   │   └── fragment_second.xml
    │   │   │   └── drawable
    │   │   │   │   ├── ic_launcher_background.xml
    │   │   │   │   └── ic_launcher_foreground.xml
    │   │   ├── kotlin
    │   │   │   └── org
    │   │   │   │   └── rewedigital
    │   │   │   │       └── katana
    │   │   │   │           └── android
    │   │   │   │               └── example
    │   │   │   │                   ├── main
    │   │   │   │                       ├── model
    │   │   │   │                       │   ├── ViewButton.kt
    │   │   │   │                       │   └── Button.kt
    │   │   │   │                       ├── view
    │   │   │   │                       │   ├── MainView.kt
    │   │   │   │                       │   └── MainActivity.kt
    │   │   │   │                       ├── navigator
    │   │   │   │                       │   └── MainNavigator.kt
    │   │   │   │                       ├── Modules.kt
    │   │   │   │                       ├── mapper
    │   │   │   │                       │   └── ButtonMapper.kt
    │   │   │   │                       ├── repository
    │   │   │   │                       │   └── ButtonRepository.kt
    │   │   │   │                       ├── interactor
    │   │   │   │                       │   └── MainInteractor.kt
    │   │   │   │                       ├── presenter
    │   │   │   │                       │   └── MainPresenter.kt
    │   │   │   │                       └── MainModule.kt
    │   │   │   │                   ├── fragment
    │   │   │   │                       ├── inject
    │   │   │   │                       │   └── Container.kt
    │   │   │   │                       ├── FragmentActivityModule.kt
    │   │   │   │                       ├── FirstFragmentModule.kt
    │   │   │   │                       ├── model
    │   │   │   │                       │   └── SecondFragmentViewModel.kt
    │   │   │   │                       ├── SecondFragmentModule.kt
    │   │   │   │                       ├── FragmentFactoryModule.kt
    │   │   │   │                       └── view
    │   │   │   │                       │   ├── FragmentActivity.kt
    │   │   │   │                       │   ├── FirstFragment.kt
    │   │   │   │                       │   └── SecondFragment.kt
    │   │   │   │                   ├── remote
    │   │   │   │                       ├── model
    │   │   │   │                       │   └── Post.kt
    │   │   │   │                       ├── JsonPlaceholderApi.kt
    │   │   │   │                       ├── JsonPlaceholderRepository.kt
    │   │   │   │                       └── RemoteModule.kt
    │   │   │   │                   ├── inject
    │   │   │   │                       └── AndroidModule.kt
    │   │   │   │                   └── KatanaApp.kt
    │   │   └── AndroidManifest.xml
    │   └── androidTest
    │   │   └── kotlin
    │   │       └── org
    │   │           └── rewedigital
    │   │               └── katana
    │   │                   └── android
    │   │                       └── example
    │   │                           ├── remote
    │   │                               ├── JsonPlaceholderApiErrorMock.kt
    │   │                               ├── TestJsonPlaceholderRepository.kt
    │   │                               └── JsonPlaceholderApiSuccessMock.kt
    │   │                           └── main
    │   │                               ├── TestModules.kt
    │   │                               └── MainEspressoTest.kt
    ├── README.md
    ├── build.gradle.kts
    └── etc
    │   └── launcher_icon.svg
├── core
    ├── src
    │   ├── main
    │   │   └── kotlin
    │   │   │   └── org
    │   │   │       └── rewedigital
    │   │   │           └── katana
    │   │   │               ├── Aliases.kt
    │   │   │               ├── dsl
    │   │   │                   ├── ModuleDslMarker.kt
    │   │   │                   ├── internal
    │   │   │                   │   └── Internal.kt
    │   │   │                   ├── ProviderDsl.kt
    │   │   │                   └── Dsl.kt
    │   │   │               ├── environment
    │   │   │                   ├── EnvironmentContext.kt
    │   │   │                   ├── MapFactory.kt
    │   │   │                   └── DefaultEnvironmentContext.kt
    │   │   │               ├── package.md
    │   │   │               ├── internal
    │   │   │                   └── Logger.kt
    │   │   │               ├── Exceptions.kt
    │   │   │               ├── Declaration.kt
    │   │   │               ├── BindingContext.kt
    │   │   │               ├── Provider.kt
    │   │   │               ├── Katana.kt
    │   │   │               ├── Key.kt
    │   │   │               ├── KatanaTrait.kt
    │   │   │               └── Module.kt
    │   └── test
    │   │   └── kotlin
    │   │       └── org
    │   │           └── rewedigital
    │   │               └── katana
    │   │                   ├── TestClasses.kt
    │   │                   ├── TestEnvironmentContext.kt
    │   │                   ├── ComponentTests.kt
    │   │                   ├── AliasTests.kt
    │   │                   ├── TypeErasureTests.kt
    │   │                   ├── KatanaTraitTests.kt
    │   │                   ├── ComponentBuilderTests.kt
    │   │                   ├── NamedInjectionTests.kt
    │   │                   ├── LoggerTests.kt
    │   │                   ├── ModuleIncludesTest.kt
    │   │                   ├── OverrideTests.kt
    │   │                   ├── ComponentDependsOnTests.kt
    │   │                   └── SetTests.kt
    └── build.gradle.kts
├── speed-comparison
    ├── src
    │   └── main
    │   │   └── kotlin
    │   │       └── org
    │   │           └── rewedigital
    │   │               └── katana
    │   │                   └── comparison
    │   │                       ├── Subject.kt
    │   │                       ├── Dependencies.kt
    │   │                       ├── KoinSubject.kt
    │   │                       ├── KodeinSubject.kt
    │   │                       ├── KatanaSubject.kt
    │   │                       └── Comparison.kt
    ├── build.gradle.kts
    └── README.md
├── gradle.properties
├── .github
    ├── ISSUE_TEMPLATE
    │   └── bug_report.md
    └── workflows
    │   └── build.yml
├── settings.gradle.kts
├── .idea
    ├── dictionaries
    │   └── sven.xml
    └── runConfigurations
    │   ├── Android_Example_Tests.xml
    │   ├── Android_Example.xml
    │   └── Android_Example__Fragment_.xml
├── LICENSE
├── gradlew.bat
├── README.md
├── gradlew
├── Getting Started.md
└── CHANGELOG.md


/android/src/main/res/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/android/src/test/kotlin/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/androidx-fragment/src/main/res/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/src/main/res/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/src/test/kotlin/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/src/main/res/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/src/test/kotlin/.gitcreate:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | -dontobfuscate
2 | -keep class org.rewedigital.katana.** { *; }
3 | 


--------------------------------------------------------------------------------
/android/proguard-consumer-rules.pro:
--------------------------------------------------------------------------------
1 | # Currently Katana does not require any specific ProGuard configuration
2 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/proguard-consumer-rules.pro:
--------------------------------------------------------------------------------
1 | # Currently Katana does not require any specific ProGuard configuration
2 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/proguard-consumer-rules.pro:
--------------------------------------------------------------------------------
1 | # Currently Katana does not require any specific ProGuard configuration
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .gradle
2 | .idea
3 | !.idea/dictionaries/
4 | !.idea/runConfigurations/
5 | *.iml
6 | build
7 | out
8 | local.properties
9 | 


--------------------------------------------------------------------------------
/android/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest package="org.rewedigital.katana.android"/>
3 | 


--------------------------------------------------------------------------------
/android-example/src/main/ic_launcher-web.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/ic_launcher-web.png


--------------------------------------------------------------------------------
/androidx-fragment/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest package="org.rewedigital.katana.androidx.fragment"/>
3 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest package="org.rewedigital.katana.androidx.viewmodel"/>
3 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Aliases.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana
2 | 
3 | internal typealias Declarations = Map<Key, Declaration<*>>
4 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/dsl/ModuleDslMarker.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana.dsl
2 | 
3 | @DslMarker
4 | annotation class ModuleDslMarker
5 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-hdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-hdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-mdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-mdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-xhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-xhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-xxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-xxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest package="org.rewedigital.katana.androidx.viewmodel.savedstate"/>
3 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rewe-digital/katana/HEAD/android-example/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/android-example/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 | 
4 |     <style name="AppTheme" parent="Theme.AppCompat.Light" />
5 | 
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/environment/EnvironmentContext.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana.environment
2 | 
3 | interface EnvironmentContext {
4 | 
5 |     fun mapFactory(): MapFactory
6 | }
7 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/environment/MapFactory.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana.environment
2 | 
3 | interface MapFactory {
4 | 
5 |     fun <K, V> create(initialCapacity: Int? = null): MutableMap<K, V>
6 | }
7 | 


--------------------------------------------------------------------------------
/speed-comparison/src/main/kotlin/org/rewedigital/katana/comparison/Subject.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.comparison
 2 | 
 3 | interface Subject {
 4 | 
 5 |     fun setup()
 6 | 
 7 |     fun execute()
 8 | 
 9 |     fun shutdown()
10 | }
11 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-all.zip
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/model/ViewButton.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana.android.example.main.model
2 | 
3 | data class ViewButton(
4 |     val id: String,
5 |     val label: String,
6 |     val message: String
7 | )
8 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/inject/Container.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana.android.example.fragment.inject
2 | 
3 | data class Container(
4 |     val activityDependency: String,
5 |     val fragmentDependency: String
6 | )
7 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/remote/model/Post.kt:
--------------------------------------------------------------------------------
1 | package org.rewedigital.katana.android.example.remote.model
2 | 
3 | data class Post(
4 |     val userId: Int,
5 |     val id: Int,
6 |     val title: String,
7 |     val body: String
8 | )
9 | 


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | android.enableJetifier=true
2 | android.useAndroidX=true
3 | kotlin.code.style=official
4 | kotlin.incremental=true
5 | kotlin.parallel.tasks.in.project=true
6 | org.gradle.jvmargs=-Xmx2048M -Dkotlin.daemon.jvm.options\="-Xmx2048M" -XX:MaxMetaspaceSize=2g
7 | org.gradle.parallel=true
8 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/model/Button.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.model
 2 | 
 3 | import androidx.annotation.StringRes
 4 | 
 5 | data class Button(
 6 |     val id: String,
 7 |     @StringRes val labelResId: Int,
 8 |     @StringRes val messageResId: Int
 9 | )
10 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background"/>
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/android-example/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background"/>
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/android-example/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <string name="app_name">Katana Android Example</string>
4 |     <string name="fragment_example">Fragment example</string>
5 |     <string name="first_fragment">First fragment %1$s %2$s</string>
6 |     <string name="second_fragment">Second fragment %1$s %2$s</string>
7 | </resources>
8 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/package.md:
--------------------------------------------------------------------------------
1 | # Package org.rewedigital.katana
2 | 
3 | ## Names
4 | 
5 | Names provided for dependencies are of type `Any`. Any reference that represents a unique identity / equality can be
6 | used as a name. That includes `String` constants, Kotlin `object`s, enum classes or custom (data) classes that implement
7 | `equals()` / `hashCode()` correctly.
8 | 


--------------------------------------------------------------------------------
/android/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     `base-android-plugin`
 3 | }
 4 | 
 5 | configureBase(
 6 |     artifactName = "katana-android",
 7 |     sourcePath = android.sourceSets["main"].java.srcDirs,
 8 |     componentName = "release"
 9 | )
10 | 
11 | dependencies {
12 |     api(project(":core"))
13 |     api(Dependencies.androidXCollection)
14 |     api(Dependencies.androidXFragment)
15 | }
16 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/view/MainView.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.view
 2 | 
 3 | interface MainView {
 4 | 
 5 |     fun addButton(id: String, label: String)
 6 | 
 7 |     fun showToast(message: String)
 8 | 
 9 |     fun showDialog()
10 | 
11 |     fun setDialogResult(result: String)
12 | 
13 |     fun dismissDialog()
14 | }
15 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/remote/JsonPlaceholderApi.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.remote
 2 | 
 3 | import kotlinx.coroutines.Deferred
 4 | import org.rewedigital.katana.android.example.remote.model.Post
 5 | import retrofit2.http.GET
 6 | 
 7 | interface JsonPlaceholderApi {
 8 | 
 9 |     @GET("posts")
10 |     fun posts(): Deferred<List<Post>>
11 | }
12 | 


--------------------------------------------------------------------------------
/androidx-fragment/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     `base-android-plugin`
 3 | }
 4 | 
 5 | configureBase(
 6 |     artifactName = "katana-androidx-fragment",
 7 |     sourcePath = android.sourceSets["main"].java.srcDirs,
 8 |     componentName = "release"
 9 | )
10 | 
11 | dependencies {
12 |     api(project(":core"))
13 |     api(Dependencies.androidXCollection)
14 |     api(Dependencies.androidXFragment)
15 | }
16 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     `base-android-plugin`
 3 | }
 4 | 
 5 | configureBase(
 6 |     artifactName = "katana-androidx-viewmodel",
 7 |     sourcePath = android.sourceSets["main"].java.srcDirs,
 8 |     componentName = "release"
 9 | )
10 | 
11 | dependencies {
12 |     api(project(":core"))
13 |     api(Dependencies.androidXFragment)
14 |     api(Dependencies.androidXLifecycleViewModel)
15 | }
16 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/FragmentActivityModule.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment
 2 | 
 3 | import org.rewedigital.katana.Module
 4 | import org.rewedigital.katana.dsl.factory
 5 | 
 6 | const val SOME_DEPENDENCY = "SOME_DEPENDENCY"
 7 | 
 8 | val FragmentActivityModule = Module {
 9 | 
10 |     factory(name = SOME_DEPENDENCY) { "SOME_DEPENDENCY" }
11 | }
12 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/navigator/MainNavigator.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.navigator
 2 | 
 3 | import android.app.Activity
 4 | 
 5 | interface MainNavigator {
 6 | 
 7 |     fun exit()
 8 | }
 9 | 
10 | class MainNavigatorImpl(private val activity: Activity) : MainNavigator {
11 | 
12 |     override fun exit() {
13 |         activity.finish()
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/FirstFragmentModule.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment
 2 | 
 3 | import org.rewedigital.katana.Module
 4 | import org.rewedigital.katana.dsl.factory
 5 | 
 6 | const val FRAGMENT_DEPENDENCY1 = "FRAGMENT_DEPENDENCY1"
 7 | 
 8 | val FirstFragmentModule = Module {
 9 | 
10 |     factory(name = FRAGMENT_DEPENDENCY1) { "FRAGMENT_DEPENDENCY1" }
11 | }
12 | 


--------------------------------------------------------------------------------
/android-example/src/androidTest/kotlin/org/rewedigital/katana/android/example/remote/JsonPlaceholderApiErrorMock.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.remote
 2 | 
 3 | import kotlinx.coroutines.Deferred
 4 | import org.rewedigital.katana.android.example.remote.model.Post
 5 | 
 6 | class JsonPlaceholderApiErrorMock : JsonPlaceholderApi {
 7 | 
 8 |     override fun posts(): Deferred<List<Post>> {
 9 |         throw IllegalArgumentException()
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/TestClasses.kt:
--------------------------------------------------------------------------------
 1 | @file:Suppress("unused")
 2 | 
 3 | package org.rewedigital.katana
 4 | 
 5 | interface MyComponent
 6 | 
 7 | class MyComponentA : MyComponent
 8 | 
 9 | class MyComponentB<T>(val value: T) : MyComponent
10 | 
11 | class MyComponentC<A, B>(
12 |     val value: A,
13 |     val value2: B
14 | ) : MyComponent
15 | 
16 | class A(val b: B)
17 | 
18 | class B(val a: A)
19 | 
20 | class A2(val b2: Lazy<B2>)
21 | 
22 | class B2(val a2: A2)
23 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: bug
 6 | assignees: svenjacobs
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is.
12 | 
13 | **Expected behavior**
14 | A clear and concise description of what you expected to happen.
15 | 
16 | **Example project**
17 | If possible, add minimal example project reproducing the issue.
18 | 
19 | **Versions**
20 | Versions of libraries used (Kotlin, Katana, etc.)
21 | 


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     `base-android-plugin`
 3 | }
 4 | 
 5 | configureBase(
 6 |     artifactName = "katana-androidx-viewmodel-savedstate",
 7 |     sourcePath = android.sourceSets["main"].java.srcDirs,
 8 |     componentName = "release"
 9 | )
10 | 
11 | dependencies {
12 |     api(project(":core"))
13 |     api(project(":androidx-viewmodel")) {
14 |         exclude(group = "androidx.lifecycle", module = "lifecycle-viewmodel")
15 |     }
16 |     api(Dependencies.androidXLifecycleViewModelSavedState)
17 | }
18 | 


--------------------------------------------------------------------------------
/speed-comparison/src/main/kotlin/org/rewedigital/katana/comparison/Dependencies.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.comparison
 2 | 
 3 | class MySingleton
 4 | 
 5 | interface MyDependency {
 6 | 
 7 |     fun execute()
 8 | }
 9 | 
10 | @Suppress("unused")
11 | class MyDependencyImpl(private val mySingleton: MySingleton) :
12 |     MyDependency {
13 | 
14 |     override fun execute() {
15 |     }
16 | }
17 | 
18 | @Suppress("unused")
19 | class MyDependency2(private val mySingleton: MySingleton) :
20 |     MyDependency {
21 | 
22 |     override fun execute() {
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/android-example/README.md:
--------------------------------------------------------------------------------
 1 | Demo Android application of the Katana dependency injection library.
 2 | 
 3 | This demo application showcases the usage of Katana on Android. It also demonstrates how UI 
 4 | ([Espresso](https://developer.android.com/training/testing/espresso/)) tests can be performed along
 5 | with Katana and mocking. Please see `MainEspressoTest`. 
 6 | 
 7 | Additionally to dependency injection the demo uses the
 8 | [Model-view-presenter](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter) 
 9 | (MVP) pattern to better showcase the capabilities of Katana.
10 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/layout/fragment_first.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:tools="http://schemas.android.com/tools"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent">
 6 | 
 7 |     <TextView
 8 |         android:id="@+id/textView"
 9 |         android:layout_width="wrap_content"
10 |         android:layout_height="wrap_content"
11 |         android:layout_gravity="center"
12 |         tools:text="First fragment" />
13 | 
14 | </FrameLayout>
15 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/environment/DefaultEnvironmentContext.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.environment
 2 | 
 3 | object DefaultEnvironmentContext : EnvironmentContext {
 4 | 
 5 |     private class DefaultMapFactory : MapFactory {
 6 | 
 7 |         override fun <K, V> create(initialCapacity: Int?): MutableMap<K, V> =
 8 |             if (initialCapacity == null) {
 9 |                 HashMap()
10 |             } else {
11 |                 HashMap(initialCapacity)
12 |             }
13 |     }
14 | 
15 |     override fun mapFactory(): MapFactory = DefaultMapFactory()
16 | }
17 | 


--------------------------------------------------------------------------------
/settings.gradle.kts:
--------------------------------------------------------------------------------
 1 | include(
 2 |     "core",
 3 |     "android",
 4 |     "androidx-fragment",
 5 |     "androidx-viewmodel",
 6 |     "androidx-viewmodel-savedstate",
 7 | 
 8 |     "speed-comparison",
 9 |     "android-example"
10 | )
11 | 
12 | pluginManagement {
13 |     repositories {
14 |         gradlePluginPortal()
15 |         google()
16 |     }
17 |     resolutionStrategy {
18 |         eachPlugin {
19 |             if (requested.id.id == "com.android.library") {
20 |                 useModule("com.android.tools.build:gradle:${requested.version}")
21 |             }
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/src/main/kotlin/org/rewedigital/katana/androidx/viewmodel/internal/Utils.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.androidx.viewmodel.internal
 2 | 
 3 | import androidx.lifecycle.ViewModel
 4 | 
 5 | /**
 6 |  * Returns name for [ViewModel] dependency binding.
 7 |  *
 8 |  * The binding under the returned name should only be used by these ViewModel extensions and not accessed
 9 |  * outside of this scope via `get()` or `inject()` for instance.
10 |  */
11 | fun <VM : ViewModel> viewModelName(modelClass: Class<VM>, key: String?) =
12 |     "ViewModel\$\$${modelClass.name}\$\$${key ?: "DEFAULT_KEY"}"
13 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/model/SecondFragmentViewModel.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment.model
 2 | 
 3 | import androidx.lifecycle.SavedStateHandle
 4 | import androidx.lifecycle.ViewModel
 5 | 
 6 | data class SecondFragmentViewModel(
 7 |     private val state: SavedStateHandle
 8 | ) : ViewModel() {
 9 | 
10 |     var message: String?
11 |         get() = state.get(KEY_MESSAGE)
12 |         set(value) {
13 |             state.set(KEY_MESSAGE, value)
14 |         }
15 | 
16 |     private companion object {
17 |         private const val KEY_MESSAGE = "MESSAGE"
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/values/main_strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 |     <string name="main_remote_button_label">Remote</string>
 4 |     <string name="main_exit_button_label">Bye</string>
 5 |     <string name="main_button1_label">Button 1</string>
 6 |     <string name="main_button1_message">You clicked the first button</string>
 7 |     <string name="main_button2_label">Button 2</string>
 8 |     <string name="main_button2_message">You clicked the second button</string>
 9 |     <string name="main_leak_label">Turn your device. There should be no memory leak after the orientation change!</string>
10 | </resources>
11 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/remote/JsonPlaceholderRepository.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.remote
 2 | 
 3 | import kotlinx.coroutines.Dispatchers
 4 | import kotlinx.coroutines.withContext
 5 | import org.rewedigital.katana.android.example.remote.model.Post
 6 | 
 7 | interface JsonPlaceholderRepository {
 8 | 
 9 |     suspend fun posts(): List<Post>
10 | }
11 | 
12 | class JsonPlaceholderRepositoryImpl(
13 |     private val api: JsonPlaceholderApi
14 | ) : JsonPlaceholderRepository {
15 | 
16 |     override suspend fun posts() =
17 |         withContext(Dispatchers.IO) {
18 |             api.posts().await()
19 |         }
20 | }
21 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/internal/Logger.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.internal
 2 | 
 3 | import org.rewedigital.katana.Katana
 4 | 
 5 | internal object Logger {
 6 | 
 7 |     fun debug(msg: () -> String) {
 8 |         Katana.logger?.debug(msg())
 9 |     }
10 | 
11 |     fun info(msg: () -> String) {
12 |         Katana.logger?.info(msg())
13 |     }
14 | 
15 |     fun warn(msg: () -> String) {
16 |         Katana.logger?.warn(msg())
17 |     }
18 | 
19 |     fun error(msgAndThrowable: () -> Pair<String, Throwable?>) {
20 |         Katana.logger?.let { logger ->
21 |             val pair = msgAndThrowable()
22 |             logger.error(pair.first, pair.second)
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/Modules.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main
 2 | 
 3 | import org.rewedigital.katana.android.example.remote.ApiModule
 4 | import org.rewedigital.katana.android.example.remote.MoshiModule
 5 | import org.rewedigital.katana.android.example.remote.RepositoryModule
 6 | import org.rewedigital.katana.android.example.remote.RetrofitModule
 7 | 
 8 | object Modules {
 9 | 
10 |     // Additional modules for main feature are placed here.
11 |     // We can replace this list during UI tests with mock modules.
12 |     var modules = listOf(
13 |         MoshiModule,
14 |         RetrofitModule,
15 |         ApiModule,
16 |         RepositoryModule
17 |     )
18 | }
19 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/mapper/ButtonMapper.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.mapper
 2 | 
 3 | import android.content.Context
 4 | import org.rewedigital.katana.android.example.main.model.Button
 5 | import org.rewedigital.katana.android.example.main.model.ViewButton
 6 | 
 7 | interface ButtonMapper {
 8 | 
 9 |     fun map(button: Button): ViewButton
10 | }
11 | 
12 | class ButtonMapperImpl(private val context: Context) : ButtonMapper {
13 | 
14 |     override fun map(button: Button) =
15 |         ViewButton(
16 |             id = button.id,
17 |             label = context.getString(button.labelResId),
18 |             message = context.getString(button.messageResId)
19 |         )
20 | }
21 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Exceptions.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | open class KatanaException(message: String, throwable: Throwable? = null) : RuntimeException(message, throwable)
 4 | 
 5 | open class ComponentException(message: String) : KatanaException(message)
 6 | 
 7 | class ComponentNotInitializedException(message: String) : ComponentException(message)
 8 | 
 9 | class InjectionException(message: String) : KatanaException(message)
10 | 
11 | class OverrideException(message: String) : KatanaException(message) {
12 |     constructor(override: String, existing: String) : this("$override would override $existing")
13 | }
14 | 
15 | class InstanceCreationException(message: String, cause: Throwable) : KatanaException(message, cause)
16 | 


--------------------------------------------------------------------------------
/core/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | @file:Suppress("UnstableApiUsage")
 2 | 
 3 | import org.jetbrains.dokka.gradle.DokkaTask
 4 | 
 5 | plugins {
 6 |     kotlin("jvm")
 7 | }
 8 | 
 9 | configureBase(
10 |     artifactName = "katana-core",
11 |     sourcePath = sourceSets["main"].allSource,
12 |     componentName = "java"
13 | )
14 | 
15 | tasks.withType(DokkaTask::class) {
16 |     dokkaSourceSets {
17 |         configureEach {
18 |             includes.from("src/main/kotlin/org/rewedigital/katana/package.md")
19 |         }
20 |     }
21 | }
22 | 
23 | val jacoco = tasks.withType<JacocoReport> {
24 |     reports {
25 |         xml.isEnabled = true
26 |         html.isEnabled = false
27 |         csv.isEnabled = false
28 |     }
29 | }
30 | tasks.getByName("check").dependsOn(jacoco)
31 | 


--------------------------------------------------------------------------------
/.idea/dictionaries/sven.xml:
--------------------------------------------------------------------------------
 1 | <component name="ProjectDictionaryState">
 2 |   <dictionary name="sven">
 3 |     <words>
 4 |       <w>amshove</w>
 5 |       <w>anko</w>
 6 |       <w>bintray</w>
 7 |       <w>constraintlayout</w>
 8 |       <w>coroutines</w>
 9 |       <w>dokka</w>
10 |       <w>jakewharton</w>
11 |       <w>jfrog</w>
12 |       <w>katana</w>
13 |       <w>kluent</w>
14 |       <w>kodein</w>
15 |       <w>koin</w>
16 |       <w>kotlinx</w>
17 |       <w>leakcanary</w>
18 |       <w>mannodermaus</w>
19 |       <w>moshi</w>
20 |       <w>nield</w>
21 |       <w>rewedigital</w>
22 |       <w>savedstate</w>
23 |       <w>spek</w>
24 |       <w>spekframework</w>
25 |       <w>squareup</w>
26 |       <w>viewmodel</w>
27 |     </words>
28 |   </dictionary>
29 | </component>
30 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/inject/AndroidModule.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.inject
 2 | 
 3 | import android.content.Context
 4 | import android.content.res.Resources
 5 | import org.rewedigital.katana.Module
 6 | import org.rewedigital.katana.android.modules.APPLICATION_CONTEXT
 7 | import org.rewedigital.katana.dsl.factory
 8 | import org.rewedigital.katana.dsl.get
 9 | 
10 | /**
11 |  * This module may provide Android specific classes like [Resources],
12 |  * [android.content.SharedPreferences], system services etc.
13 |  *
14 |  * @see org.rewedigital.katana.android.modules.createApplicationModule
15 |  */
16 | val AndroidModule = Module {
17 | 
18 |     factory { get<Context>(APPLICATION_CONTEXT).resources }
19 | }
20 | 


--------------------------------------------------------------------------------
/android-example/src/androidTest/kotlin/org/rewedigital/katana/android/example/remote/TestJsonPlaceholderRepository.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.remote
 2 | 
 3 | import androidx.test.espresso.idling.CountingIdlingResource
 4 | import org.rewedigital.katana.android.example.remote.model.Post
 5 | 
 6 | class TestJsonPlaceholderRepository(
 7 |     private val repository: JsonPlaceholderRepository,
 8 |     private val repositoryIdlingResource: CountingIdlingResource
 9 | ) : JsonPlaceholderRepository {
10 | 
11 |     override suspend fun posts(): List<Post> {
12 |         repositoryIdlingResource.increment()
13 |         try {
14 |             return repository.posts()
15 |         } finally {
16 |             repositoryIdlingResource.decrement()
17 |         }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/layout/dialog_remote.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent">
 5 | 
 6 |     <ProgressBar
 7 |         android:id="@+id/progressBar"
 8 |         android:layout_width="match_parent"
 9 |         android:layout_height="match_parent"
10 |         android:layout_gravity="center"
11 |         android:layout_margin="8dp"
12 |         android:indeterminate="true" />
13 | 
14 |     <TextView
15 |         android:id="@+id/textView"
16 |         android:layout_width="match_parent"
17 |         android:layout_height="match_parent"
18 |         android:layout_gravity="center"
19 |         android:layout_margin="8dp" />
20 | 
21 | </FrameLayout>
22 | 


--------------------------------------------------------------------------------
/speed-comparison/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     kotlin("jvm")
 3 | }
 4 | 
 5 | dependencies {
 6 |     implementation(project(":core"))
 7 |     implementation("org.nield:kotlin-statistics:1.2.1")
 8 |     implementation("org.koin:koin-core:2.0.1")
 9 |     implementation("org.kodein.di:kodein-di-erased-jvm:6.3.3")
10 | }
11 | 
12 | val fatJar = task("fatJar", type = Jar::class) {
13 |     archiveBaseName.set("${project.name}-fat")
14 |     manifest {
15 |         attributes["Main-Class"] = "org.rewedigital.katana.comparison.ComparisonKt"
16 |     }
17 |     from(configurations.runtimeClasspath.get().map { if (it.isDirectory) it else zipTree(it) })
18 |     with(tasks["jar"] as CopySpec)
19 | 
20 |     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
21 | }
22 | 
23 | tasks {
24 |     "build" {
25 |         dependsOn(fatJar)
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/TestEnvironmentContext.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.rewedigital.katana.environment.EnvironmentContext
 4 | import org.rewedigital.katana.environment.MapFactory
 5 | 
 6 | /**
 7 |  * Ensures a defined order of dependency declarations resulting in stable and predictable tests by configuring Katana
 8 |  * to use a [LinkedHashMap].
 9 |  */
10 | object TestEnvironmentContext : EnvironmentContext {
11 | 
12 |     private class TestMapFactory : MapFactory {
13 | 
14 |         override fun <K, V> create(initialCapacity: Int?): MutableMap<K, V> =
15 |             when (initialCapacity) {
16 |                 null -> LinkedHashMap()
17 |                 else -> LinkedHashMap(initialCapacity)
18 |             }
19 |     }
20 | 
21 |     override fun mapFactory(): MapFactory = TestMapFactory()
22 | }
23 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Declaration.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | /**
 4 |  * Represents a dependency declaration.
 5 |  */
 6 | @PublishedApi
 7 | internal data class Declaration<T>(
 8 |     val key: Key,
 9 |     val type: Type,
10 |     val moduleId: Int,
11 |     val moduleName: String?,
12 |     val clazz: Class<T>,
13 |     val name: Any?,
14 |     val provider: Provider<T>,
15 |     val internal: Boolean
16 | ) {
17 | 
18 |     enum class Type(
19 |         val permitsRedeclaration: Boolean = false
20 |     ) {
21 |         FACTORY,
22 |         SINGLETON,
23 |         EAGER_SINGLETON,
24 |         SET(permitsRedeclaration = true),
25 |         CUSTOM
26 |     }
27 | 
28 |     override fun toString() =
29 |         "${clazz.name}(type=$type${name?.let { ", name=$it" }.orEmpty()}${moduleName?.let { ", module=$it" }.orEmpty()})"
30 | }
31 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/README.md:
--------------------------------------------------------------------------------
 1 | # AndroidX ViewModel extensions for Katana
 2 | 
 3 | The extensions declared in this artifact simplify [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel)
 4 | injection with Katana. Also see [katana-androidx-viewmodel-savedstate](../androidx-viewmodel-savedstate).
 5 | 
 6 | Create a ViewModel binding inside a module:
 7 | 
 8 | ```kotlin
 9 | data class MyViewModel(val someDependency: SomeDependency) : ViewModel()
10 | 
11 | Module {
12 |     
13 |     viewModel { MyViewModel(get()) }
14 | }
15 | ```
16 | 
17 | Inject ViewModel in your `Activity` or `Fragment`:
18 | 
19 | ```kotlin
20 | class MyFragment : Fragment(),
21 |                    KatanaTrait {
22 |                    
23 |     override val component = Component(...)
24 |     
25 |     private val viewModel by viewModel<MyViewModel, MyFragment>() 
26 | }
27 | ```
28 | 


--------------------------------------------------------------------------------
/android-example/src/androidTest/kotlin/org/rewedigital/katana/android/example/remote/JsonPlaceholderApiSuccessMock.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.remote
 2 | 
 3 | import kotlinx.coroutines.CompletableDeferred
 4 | import kotlinx.coroutines.Deferred
 5 | import org.rewedigital.katana.android.example.remote.model.Post
 6 | 
 7 | class JsonPlaceholderApiSuccessMock : JsonPlaceholderApi {
 8 | 
 9 |     override fun posts(): Deferred<List<Post>> =
10 |         CompletableDeferred(
11 |             listOf(
12 |                 Post(
13 |                     userId = 1,
14 |                     id = 1,
15 |                     title = "Lorem ipsum",
16 |                     body = "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
17 |                 )
18 |             )
19 |         )
20 | }
21 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/SecondFragmentModule.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment
 2 | 
 3 | import org.rewedigital.katana.Module
 4 | import org.rewedigital.katana.android.example.fragment.inject.Container
 5 | import org.rewedigital.katana.android.example.fragment.model.SecondFragmentViewModel
 6 | import org.rewedigital.katana.androidx.viewmodel.savedstate.viewModelSavedState
 7 | import org.rewedigital.katana.dsl.factory
 8 | import org.rewedigital.katana.dsl.get
 9 | 
10 | const val FRAGMENT_DEPENDENCY2 = "FRAGMENT_DEPENDENCY2"
11 | 
12 | val SecondFragmentModule = Module {
13 | 
14 |     factory(name = FRAGMENT_DEPENDENCY2) { "FRAGMENT_DEPENDENCY2" }
15 | 
16 |     factory { Container(get(SOME_DEPENDENCY), get(FRAGMENT_DEPENDENCY2)) }
17 | 
18 |     viewModelSavedState { state -> SecondFragmentViewModel(state) }
19 | }
20 | 


--------------------------------------------------------------------------------
/android/src/main/kotlin/org/rewedigital/katana/android/AndroidKatanaLogger.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android
 2 | 
 3 | import android.util.Log
 4 | import org.rewedigital.katana.Katana
 5 | 
 6 | /**
 7 |  * Android specific [Katana.Logger] implementation.
 8 |  *
 9 |  * @see Katana.logger
10 |  */
11 | object AndroidKatanaLogger : Katana.Logger {
12 | 
13 |     private const val TAG = "KATANA"
14 | 
15 |     override fun debug(msg: String) {
16 |         Log.d(TAG, msg)
17 |     }
18 | 
19 |     override fun info(msg: String) {
20 |         Log.i(TAG, msg)
21 |     }
22 | 
23 |     override fun warn(msg: String) {
24 |         Log.w(TAG, msg)
25 |     }
26 | 
27 |     override fun error(msg: String, throwable: Throwable?) {
28 |         if (throwable != null) {
29 |             Log.e(TAG, msg, throwable)
30 |         } else {
31 |             Log.e(TAG, msg)
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/FragmentFactoryModule.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment
 2 | 
 3 | import org.rewedigital.katana.Module
 4 | import org.rewedigital.katana.android.example.fragment.view.FirstFragment
 5 | import org.rewedigital.katana.android.example.fragment.view.SecondFragment
 6 | import org.rewedigital.katana.androidx.fragment.KatanaFragmentFactory
 7 | import org.rewedigital.katana.dsl.component
 8 | import org.rewedigital.katana.dsl.factory
 9 | import org.rewedigital.katana.dsl.singleton
10 | 
11 | val FragmentFactoryModule = Module(
12 |     name = "FragmentFactoryModule"
13 | ) {
14 | 
15 |     singleton {
16 |         KatanaFragmentFactory(component)
17 |             .handlesFragment<FirstFragment>()
18 |             .handlesFragment<SecondFragment>()
19 |     }
20 | 
21 |     factory { FirstFragment(component) }
22 | 
23 |     factory { SecondFragment(component) }
24 | }
25 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/drawable/ic_launcher_background.xml:
--------------------------------------------------------------------------------
 1 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
 2 |         xmlns:aapt="http://schemas.android.com/aapt"
 3 |         android:width="108dp"
 4 |         android:height="108dp"
 5 |         android:viewportWidth="28.574999"
 6 |         android:viewportHeight="28.575">
 7 |     <path
 8 |             android:pathData="M0,0h28.575v28.575h-28.575z"
 9 |             android:strokeWidth="0.29316965"
10 |             android:fillAlpha="1">
11 |         <aapt:attr name="android:fillColor">
12 |             <gradient
13 |                     android:startY="4.7625"
14 |                     android:startX="4.7625"
15 |                     android:endY="23.8125"
16 |                     android:endX="23.8125"
17 |                     android:type="linear">
18 |                 <item android:offset="0" android:color="#FFFF4242"/>
19 |                 <item android:offset="1" android:color="#FFFF0D0D"/>
20 |             </gradient>
21 |         </aapt:attr>
22 |     </path>
23 | </vector>
24 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/ComponentTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldThrow
 4 | import org.spekframework.spek2.Spek
 5 | import org.spekframework.spek2.style.specification.describe
 6 | 
 7 | object ComponentTests : Spek(
 8 |     {
 9 |         describe("Components") {
10 | 
11 |             it("should throw exception when no modules or parent components were passed") {
12 |                 val fn = {
13 |                     Component()
14 |                 }
15 | 
16 |                 fn shouldThrow ComponentException::class
17 |             }
18 | 
19 |             it("should throw exception when all modules are empty") {
20 |                 val fn = {
21 |                     val module1 = Module {
22 |                     }
23 | 
24 |                     val module2 = Module {
25 |                     }
26 | 
27 |                     Component(module1, module2)
28 |                 }
29 | 
30 |                 fn shouldThrow ComponentException::class
31 |             }
32 |         }
33 |     })
34 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/BindingContext.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.rewedigital.katana.dsl.ModuleDslMarker
 4 | import java.util.concurrent.atomic.AtomicInteger
 5 | 
 6 | abstract class BindingContext {
 7 |     internal abstract val module: Module
 8 |     internal abstract val key: Key?
 9 |     internal abstract val increment: Int?
10 | }
11 | 
12 | @ModuleDslMarker
13 | class ModuleBindingContext internal constructor(
14 |     @PublishedApi override val module: Module
15 | ) : BindingContext() {
16 | 
17 |     override val key: Key? = null
18 |     override val increment: Int? = null
19 | }
20 | 
21 | @ModuleDslMarker
22 | @Suppress("unused")
23 | class SetBindingContext<T> @PublishedApi internal constructor(
24 |     override val module: Module,
25 |     @PublishedApi override val key: Key
26 | ) : BindingContext() {
27 | 
28 |     override val increment
29 |         get() = nextIncrement.getAndIncrement()
30 | 
31 |     private companion object {
32 |         private val nextIncrement = AtomicInteger()
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/speed-comparison/src/main/kotlin/org/rewedigital/katana/comparison/KoinSubject.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.comparison
 2 | 
 3 | import org.koin.core.KoinComponent
 4 | import org.koin.core.context.startKoin
 5 | import org.koin.core.context.stopKoin
 6 | import org.koin.core.inject
 7 | import org.koin.dsl.bind
 8 | import org.koin.dsl.module
 9 | 
10 | class KoinSubject : Subject, KoinComponent {
11 | 
12 |     override fun setup() {
13 |         val module = module {
14 | 
15 |             single { MySingleton() }
16 | 
17 |             factory { MyDependencyImpl(get()) } bind MyDependency::class
18 | 
19 |             factory { MyDependency2(get()) }
20 |         }
21 | 
22 |         startKoin {
23 |             modules(module)
24 |         }
25 |     }
26 | 
27 |     override fun execute() {
28 |         val dependency: MyDependency by inject()
29 |         val dependency2: MyDependency2 by inject()
30 | 
31 |         dependency.execute()
32 |         dependency2.execute()
33 |     }
34 | 
35 |     override fun shutdown() {
36 |         stopKoin()
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT license (MIT)
 2 | 
 3 | Copyright (c) 2019 REWE Digital GmbH
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 6 | documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 7 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
 8 | persons to whom the Software is furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
11 | Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
14 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
15 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
16 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
17 | 


--------------------------------------------------------------------------------
/speed-comparison/src/main/kotlin/org/rewedigital/katana/comparison/KodeinSubject.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.comparison
 2 | 
 3 | import org.kodein.di.Kodein
 4 | import org.kodein.di.erased.bind
 5 | import org.kodein.di.erased.instance
 6 | import org.kodein.di.erased.provider
 7 | import org.kodein.di.erased.singleton
 8 | 
 9 | class KodeinSubject : Subject {
10 | 
11 |     private lateinit var kodein: Kodein
12 | 
13 |     override fun setup() {
14 |         kodein = Kodein {
15 | 
16 |             bind<MySingleton>() with singleton { MySingleton() }
17 | 
18 |             bind<MyDependency>() with provider {
19 |                 MyDependencyImpl(instance())
20 |             }
21 | 
22 |             bind<MyDependency2>() with provider {
23 |                 MyDependency2(instance())
24 |             }
25 |         }
26 |     }
27 | 
28 |     override fun execute() {
29 |         val dependency: MyDependency by kodein.instance()
30 |         val dependency2: MyDependency2 by kodein.instance()
31 | 
32 |         dependency.execute()
33 |         dependency2.execute()
34 |     }
35 | 
36 |     override fun shutdown() {
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/speed-comparison/src/main/kotlin/org/rewedigital/katana/comparison/KatanaSubject.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.comparison
 2 | 
 3 | import org.rewedigital.katana.Component
 4 | import org.rewedigital.katana.KatanaTrait
 5 | import org.rewedigital.katana.Module
 6 | import org.rewedigital.katana.dsl.factory
 7 | import org.rewedigital.katana.dsl.get
 8 | import org.rewedigital.katana.dsl.singleton
 9 | import org.rewedigital.katana.inject
10 | 
11 | class KatanaSubject : Subject, KatanaTrait {
12 | 
13 |     override lateinit var component: Component
14 | 
15 |     override fun setup() {
16 |         val module = Module {
17 | 
18 |             singleton { MySingleton() }
19 | 
20 |             factory<MyDependency> { MyDependencyImpl(get()) }
21 | 
22 |             factory { MyDependency2(get()) }
23 |         }
24 | 
25 |         component = Component(module)
26 |     }
27 | 
28 |     override fun execute() {
29 |         val dependency: MyDependency by inject()
30 |         val dependency2: MyDependency2 by inject()
31 | 
32 |         dependency.execute()
33 |         dependency2.execute()
34 |     }
35 | 
36 |     override fun shutdown() {
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/androidx-fragment/README.md:
--------------------------------------------------------------------------------
 1 | # Fragment constructor injection with FragmentFactory
 2 | 
 3 | This artifact provides additional support for `androidx.fragment` enabling constructor injection in Fragments with
 4 | `KatanaFragmentFactory`.
 5 | 
 6 | ```kotlin
 7 | // In a module: 
 8 | 
 9 | val module = Module {
10 | 
11 |     singleton {
12 |         KatanaFragmentFactory(component)
13 |             .handlesFragment<FirstFragment>()
14 |             .handlesFragment<SecondFragment>(name = "SecondFragment")
15 |     }
16 | 
17 |     factory { FirstFragment(get()) }
18 | 
19 |     factory(name = "SecondFragment") { SecondFragment(get(), get()) }
20 | }
21 | 
22 | // ... then in an Activity:
23 | 
24 | class MyActivity : AppCompatActivity() {
25 | 
26 |     private val fragmentFactory by applicationComponent.inject<KatanaFragmentFactory>()
27 | 
28 |     override fun onCreate(savedInstanceState: Bundle?) {
29 |         // Must be set **before** super call for Fragment instantiation after orientation change
30 |         supportFragmentManager.fragmentFactory = fragmentFactory
31 | 
32 |         super.onCreate(savedInstanceState)
33 |     
34 |         // ...
35 |     }
36 | }
37 | ```
38 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/repository/ButtonRepository.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.repository
 2 | 
 3 | import org.rewedigital.katana.android.example.R
 4 | import org.rewedigital.katana.android.example.main.model.Button
 5 | 
 6 | interface ButtonRepository {
 7 | 
 8 |     fun fetch(): List<Button>
 9 | 
10 |     fun findById(id: String): Button?
11 | }
12 | 
13 | class ButtonRepositoryImpl : ButtonRepository {
14 | 
15 |     override fun fetch() = BUTTONS
16 | 
17 |     override fun findById(id: String) = BUTTONS.find { button -> button.id == id }
18 | 
19 |     private companion object {
20 | 
21 |         private val BUTTONS = listOf(
22 |             Button(
23 |                 id = "cd6a5c60-9ac6-401d-b92e-29a765fb56bf",
24 |                 labelResId = R.string.main_button1_label,
25 |                 messageResId = R.string.main_button1_message
26 |             ),
27 |             Button(
28 |                 id = "bae39808-9735-418a-9684-5f028f0dea91",
29 |                 labelResId = R.string.main_button2_label,
30 |                 messageResId = R.string.main_button2_message
31 |             )
32 |         )
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Provider.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.rewedigital.katana.dsl.ProviderDsl
 4 | 
 5 | /**
 6 |  * Describes how a dependency is provided
 7 |  */
 8 | interface Provider<T> {
 9 | 
10 |     /**
11 |      * The [ComponentContext] of the current context is passed to the function which enables transitive dependency
12 |      * injection, e.g. injection of dependencies within a module.
13 |      */
14 |     operator fun invoke(context: ComponentContext, arg: Any? = null): T
15 | }
16 | 
17 | @PublishedApi
18 | internal class DefaultProvider<T>(
19 |     private val body: ProviderDsl.() -> T
20 | ) : Provider<T> {
21 | 
22 |     override operator fun invoke(context: ComponentContext, arg: Any?): T =
23 |         body.invoke(ProviderDsl(context))
24 | }
25 | 
26 | @PublishedApi
27 | internal class SetProvider<T, S : Set<T>>(
28 |     private val key: Key
29 | ) : Provider<S> {
30 | 
31 |     @Suppress("UNCHECKED_CAST")
32 |     override fun invoke(context: ComponentContext, arg: Any?): S =
33 |         context.findKeysForContext(key).map { contextKey ->
34 |             context.findInstanceOrThrow<T>(contextKey).value
35 |         }.toSet() as S
36 | }
37 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/dsl/internal/Internal.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.dsl.internal
 2 | 
 3 | import org.rewedigital.katana.*
 4 | 
 5 | @PublishedApi
 6 | internal fun <CTX : BindingContext, T> declaration(
 7 |     context: CTX,
 8 |     clazz: Class<T>,
 9 |     name: Any?,
10 |     internal: Boolean,
11 |     type: Declaration.Type,
12 |     provider: Provider<T>
13 | ): CTX {
14 |     val key = Key.of(
15 |         clazz = clazz,
16 |         name = name,
17 |         contextKey = context.key,
18 |         increment = context.increment
19 |     )
20 | 
21 |     val declaration =
22 |         Declaration(
23 |             key = key,
24 |             type = type,
25 |             moduleId = context.module.id,
26 |             moduleName = context.module.name,
27 |             clazz = clazz,
28 |             name = name,
29 |             provider = provider,
30 |             internal = internal
31 |         )
32 | 
33 |     val existingDeclaration = context.module.declarations[key]
34 |     if (existingDeclaration != null) {
35 |         throw OverrideException(declaration.toString(), existingDeclaration.toString())
36 |     }
37 | 
38 |     context.module.declarations[key] = declaration
39 |     return context
40 | }
41 | 


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/README.md:
--------------------------------------------------------------------------------
 1 | # AndroidX ViewModel Saved State extensions for Katana
 2 | 
 3 | The extensions declared in this artifact provide support for injection of [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel)
 4 | with [Saved State module](https://developer.android.com/topic/libraries/architecture/viewmodel-savedstate). Also see
 5 | [katana-androidx-viewmodel](../androidx-viewmodel).
 6 | 
 7 | Create a ViewModel binding inside a module:
 8 | 
 9 | ```kotlin
10 | data class MyViewModel(
11 |     val state: SavedStateHandle,
12 |     val someDependency: SomeDependency
13 | ) : ViewModel() {
14 | 
15 |     var someValue: String?
16 |         get() = state.get("SOME_VALUE")
17 |         set(value) {
18 |             state.set("SOME_VALUE", value)
19 |         }
20 | }
21 | 
22 | Module {
23 |     
24 |     viewModelSavedState { state -> MyViewModel(state, get()) }
25 | }
26 | ```
27 | 
28 | Inject ViewModel in your `Activity` or `Fragment`:
29 | 
30 | ```kotlin
31 | class MyFragment : Fragment(),
32 |                    KatanaTrait {
33 |                    
34 |     override val component = Component(...)
35 |     
36 |     private val viewModel by viewModelSavedState<MyViewModel, MyFragment>() 
37 | }
38 | ```
39 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:tools="http://schemas.android.com/tools"
 4 |     android:id="@+id/rootView"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent"
 7 |     android:layout_margin="8dp"
 8 |     android:orientation="vertical"
 9 |     tools:context="org.rewedigital.katana.android.example.main.view.MainActivity">
10 | 
11 |     <Button
12 |         android:id="@+id/remoteButton"
13 |         android:layout_width="match_parent"
14 |         android:layout_height="wrap_content"
15 |         android:text="@string/main_remote_button_label" />
16 | 
17 |     <Button
18 |         android:id="@+id/exitButton"
19 |         android:layout_width="match_parent"
20 |         android:layout_height="wrap_content"
21 |         android:text="@string/main_exit_button_label" />
22 | 
23 |     <TextView
24 |         android:layout_width="match_parent"
25 |         android:layout_height="wrap_content"
26 |         android:layout_marginTop="8dp"
27 |         android:text="@string/main_leak_label"
28 |         android:textAppearance="?android:attr/textAppearanceSmall" />
29 | 
30 | </LinearLayout>
31 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/interactor/MainInteractor.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.interactor
 2 | 
 3 | import org.rewedigital.katana.android.example.main.mapper.ButtonMapper
 4 | import org.rewedigital.katana.android.example.main.model.ViewButton
 5 | import org.rewedigital.katana.android.example.main.repository.ButtonRepository
 6 | import org.rewedigital.katana.android.example.remote.JsonPlaceholderRepository
 7 | import org.rewedigital.katana.android.example.remote.model.Post
 8 | 
 9 | interface MainInteractor {
10 | 
11 |     fun fetchButtons(): List<ViewButton>
12 | 
13 |     fun findButtonById(id: String): ViewButton?
14 | 
15 |     suspend fun fetchPosts(): List<Post>
16 | }
17 | 
18 | class MainInteractorImpl(
19 |     private val buttonRepository: ButtonRepository,
20 |     private val jsonPlaceholderRepository: JsonPlaceholderRepository,
21 |     private val mapper: ButtonMapper
22 | ) : MainInteractor {
23 | 
24 |     override fun fetchButtons() = buttonRepository.fetch().map(mapper::map).reversed()
25 | 
26 |     override fun findButtonById(id: String) = buttonRepository.findById(id)?.let(mapper::map)
27 | 
28 |     override suspend fun fetchPosts() = jsonPlaceholderRepository.posts()
29 | }
30 | 


--------------------------------------------------------------------------------
/android/src/main/kotlin/org/rewedigital/katana/android/fragment/KatanaFragment.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.fragment
 2 | 
 3 | import android.app.Activity
 4 | import android.os.Bundle
 5 | import androidx.fragment.app.Fragment
 6 | 
 7 | /**
 8 |  * Base class for Fragments with Katana dependency injection.
 9 |  *
10 |  * [onInject] must be implemented where component initialization and injection should take place.
11 |  * It is called after [onActivityCreated]. For a more detailed explanation see [KatanaFragmentDelegate].
12 |  *
13 |  * If this base class cannot be used because the Fragment must extend from another class,
14 |  * [KatanaFragmentDelegate] can still be used individually.
15 |  *
16 |  * @see KatanaFragmentDelegate
17 |  */
18 | abstract class KatanaFragment : Fragment() {
19 | 
20 |     private val fragmentDelegate: KatanaFragmentDelegate<KatanaFragment>
21 | 
22 |     init {
23 |         fragmentDelegate = fragmentDelegate { activity, savedInstanceState -> onInject(activity, savedInstanceState) }
24 |     }
25 | 
26 |     override fun onActivityCreated(savedInstanceState: Bundle?) {
27 |         super.onActivityCreated(savedInstanceState)
28 | 
29 |         fragmentDelegate.onActivityCreated(savedInstanceState)
30 |     }
31 | 
32 |     abstract fun onInject(activity: Activity, savedInstanceState: Bundle?)
33 | }
34 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: Build
 2 | 
 3 | on:
 4 |   push:
 5 |   workflow_dispatch:
 6 | 
 7 | jobs:
 8 |   build:
 9 |     timeout-minutes: 30
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - uses: actions/checkout@v2
14 | 
15 |       - uses: actions/setup-java@v2
16 |         with:
17 |           distribution: 'adopt'
18 |           java-version: '11'
19 | 
20 |       - name: Cache Gradle packages
21 |         uses: actions/cache@v2
22 |         with:
23 |           path: ~/.gradle/caches
24 |           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
25 |           restore-keys: ${{ runner.os }}-gradle
26 | 
27 |       - name: Test
28 |         run: ./gradlew test
29 | 
30 |       - name: Deploy
31 |         if: github.ref == 'refs/heads/main'
32 |         run: ./gradlew publishToSonatype closeAndReleaseSonatypeStagingRepository
33 |         env:
34 |           SONATYPE_NEXUS_USERNAME: ${{ secrets.SONATYPE_NEXUS_USERNAME }}
35 |           SONATYPE_NEXUS_PASSWORD: ${{ secrets.SONATYPE_NEXUS_PASSWORD }}
36 |           SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
37 |           SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
38 | 
39 |       - uses: actions/upload-artifact@v2
40 |         with:
41 |           path: |
42 |             **/build/libs/*.jar
43 |             **/build/outputs/apk/**/*.apk
44 |             **/build/outputs/bundle/**/*.aab
45 | 


--------------------------------------------------------------------------------
/android/README.md:
--------------------------------------------------------------------------------
 1 | This artifact provides:
 2 | 
 3 |   * Module factory functions for `Application`, `Activity` and `Fragment` modules.
 4 |     See functions under `org.rewedigital.katana.android.modules`.
 5 | 
 6 |   * An `AndroidEnvironmentContext` for optimizing Katana's behaviour on Android.
 7 |     See `Katana.environmentContext`.
 8 |     
 9 |   * `KatanaFragment` and `KatanaFragmentDelegate` for simplifying usage of Katana with Fragments.
10 | 
11 |   * Android specific Katana logger implementation `AndroidKatanaLogger`.
12 | 
13 | ## Optimizing Katana on Android
14 | 
15 | This artifact provides an `AndroidEnvironmentContext`, which optimizes Katana's behaviour on Android. To enable this 
16 | `EnvironmentContext`, assign it to `Katana.environmentContext` as soon as possible in your application's lifecycle and 
17 | **before** any Katana modules and components are created.
18 | 
19 | ```kotlin
20 | Katana.environmentContext = AndroidEnvironmentContext()
21 | ```
22 | 
23 | By default this context improves memory consumption at the cost of speed. If memory is not a concern but speed is,
24 | use `AndroidEnvironmentContext(profile = SPEED)`.
25 | 
26 | ## AndroidX ViewModel
27 | 
28 | Looking for AndroidX ViewModel support? Have a look at the [katana-androidx-viewmodel](../androidx-viewmodel) artifact.
29 |   
30 | ## ProGuard
31 | 
32 | Katana does not require any specific ProGuard configuration 😎.
33 | 


--------------------------------------------------------------------------------
/.idea/runConfigurations/Android_Example_Tests.xml:
--------------------------------------------------------------------------------
 1 | <component name="ProjectRunConfigurationManager">
 2 |   <configuration default="false" name="Android Example Tests" type="AndroidTestRunConfigurationType" factoryName="Android Instrumented Tests">
 3 |     <module name="katana.android-example" />
 4 |     <option name="TESTING_TYPE" value="0" />
 5 |     <option name="METHOD_NAME" value="" />
 6 |     <option name="CLASS_NAME" value="" />
 7 |     <option name="PACKAGE_NAME" value="" />
 8 |     <option name="INSTRUMENTATION_RUNNER_CLASS" value="" />
 9 |     <option name="EXTRA_OPTIONS" value="" />
10 |     <option name="INCLUDE_GRADLE_EXTRA_OPTIONS" value="true" />
11 |     <option name="CLEAR_LOGCAT" value="false" />
12 |     <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
13 |     <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
14 |     <option name="FORCE_STOP_RUNNING_APP" value="true" />
15 |     <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
16 |     <option name="DEBUGGER_TYPE" value="Java" />
17 |     <Java />
18 |     <Profilers>
19 |       <option name="ADVANCED_PROFILING_ENABLED" value="false" />
20 |       <option name="STARTUP_CPU_PROFILING_ENABLED" value="false" />
21 |       <option name="STARTUP_CPU_PROFILING_CONFIGURATION_NAME" value="Sample Java Methods" />
22 |     </Profilers>
23 |     <method v="2">
24 |       <option name="Android.Gradle.BeforeRunTask" enabled="true" />
25 |     </method>
26 |   </configuration>
27 | </component>


--------------------------------------------------------------------------------
/android-example/src/androidTest/kotlin/org/rewedigital/katana/android/example/main/TestModules.kt:
--------------------------------------------------------------------------------
 1 | @file:Suppress("TestFunctionName")
 2 | 
 3 | package org.rewedigital.katana.android.example.main
 4 | 
 5 | import androidx.test.espresso.idling.CountingIdlingResource
 6 | import org.rewedigital.katana.Module
 7 | import org.rewedigital.katana.android.example.remote.*
 8 | import org.rewedigital.katana.dsl.get
 9 | import org.rewedigital.katana.dsl.singleton
10 | 
11 | val TestSuccessApiMockModule = Module("TestSuccessApiMockModule") {
12 | 
13 |     singleton<JsonPlaceholderApi> {
14 |         JsonPlaceholderApiSuccessMock()
15 |     }
16 | }
17 | 
18 | val TestErrorApiMockModule = Module("TestErrorApiMockModule") {
19 | 
20 |     singleton<JsonPlaceholderApi> {
21 |         JsonPlaceholderApiErrorMock()
22 |     }
23 | }
24 | 
25 | const val TEST_REPO = "TEST_REPO"
26 | const val TEST_IDLING_RESOURCE = "TEST_IDLING_RESOURCE"
27 | 
28 | fun TestRepositoryModule(repositoryIdlingResource: CountingIdlingResource) =
29 |     Module("testRepositoryModule") {
30 | 
31 |         singleton(name = TEST_IDLING_RESOURCE) { repositoryIdlingResource }
32 | 
33 |         singleton<JsonPlaceholderRepository>(name = TEST_REPO) { JsonPlaceholderRepositoryImpl(get()) }
34 | 
35 |         singleton<JsonPlaceholderRepository> {
36 |             TestJsonPlaceholderRepository(
37 |                 get(TEST_REPO),
38 |                 get(TEST_IDLING_RESOURCE)
39 |             )
40 |         }
41 |     }
42 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Katana.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.rewedigital.katana.Katana.Logger
 4 | import org.rewedigital.katana.Katana.environmentContext
 5 | import org.rewedigital.katana.Katana.logger
 6 | import org.rewedigital.katana.environment.DefaultEnvironmentContext
 7 | import org.rewedigital.katana.environment.EnvironmentContext
 8 | 
 9 | /**
10 |  * Global Katana configuration object.
11 |  *
12 |  * Provides the possibility to specify a [Logger] via [logger] and an [EnvironmentContext] via [environmentContext]
13 |  * for configuring Katana for a specific runtime environment.
14 |  *
15 |  * @see Logger
16 |  * @see logger
17 |  * @see EnvironmentContext
18 |  * @see environmentContext
19 |  */
20 | object Katana {
21 | 
22 |     interface Logger {
23 | 
24 |         fun debug(msg: String)
25 | 
26 |         fun info(msg: String)
27 | 
28 |         fun warn(msg: String)
29 | 
30 |         fun error(msg: String, throwable: Throwable? = null)
31 |     }
32 | 
33 |     /**
34 |      * Pass an implementation of [Logger] here to enable Katana's logging functionality
35 |      */
36 |     var logger: Logger? = null
37 | 
38 |     /**
39 |      * Configures Katana for a specific runtime environment.
40 |      *
41 |      * This property must be set very early in the application lifecycle. Preferably before any modules and components
42 |      * are created.
43 |      */
44 |     var environmentContext: EnvironmentContext = DefaultEnvironmentContext
45 | }
46 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/remote/RemoteModule.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.remote
 2 | 
 3 | import com.jakewharton.retrofit2.adapter.kotlin.coroutines.CoroutineCallAdapterFactory
 4 | import com.squareup.moshi.Moshi
 5 | import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
 6 | import org.rewedigital.katana.Module
 7 | import org.rewedigital.katana.dsl.factory
 8 | import org.rewedigital.katana.dsl.get
 9 | import org.rewedigital.katana.dsl.singleton
10 | import retrofit2.Retrofit
11 | import retrofit2.converter.moshi.MoshiConverterFactory
12 | 
13 | val MoshiModule = Module("MoshiModule") {
14 | 
15 |     singleton {
16 |         Moshi.Builder()
17 |             .add(KotlinJsonAdapterFactory())
18 |             .build()
19 |     }
20 | }
21 | 
22 | val RetrofitModule = Module("RetrofitModule") {
23 | 
24 |     factory {
25 |         Retrofit.Builder()
26 |             .addCallAdapterFactory(CoroutineCallAdapterFactory())
27 |             .addConverterFactory(MoshiConverterFactory.create(get()))
28 |     }
29 | }
30 | 
31 | val ApiModule = Module("ApiModule") {
32 | 
33 |     singleton {
34 |         get<Retrofit.Builder>()
35 |             .baseUrl("https://jsonplaceholder.typicode.com/")
36 |             .build()
37 |             .create(JsonPlaceholderApi::class.java)
38 |     }
39 | }
40 | 
41 | val RepositoryModule = Module("RepositoryModule") {
42 | 
43 |     singleton<JsonPlaceholderRepository> { JsonPlaceholderRepositoryImpl(get()) }
44 | }
45 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/view/FragmentActivity.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment.view
 2 | 
 3 | import android.os.Bundle
 4 | import androidx.appcompat.app.AppCompatActivity
 5 | import org.rewedigital.katana.Component
 6 | import org.rewedigital.katana.KatanaTrait
 7 | import org.rewedigital.katana.android.example.R
 8 | import org.rewedigital.katana.android.example.fragment.FragmentActivityModule
 9 | import org.rewedigital.katana.android.example.fragment.FragmentFactoryModule
10 | import org.rewedigital.katana.android.modules.ActivityModule
11 | import org.rewedigital.katana.androidx.fragment.KatanaFragmentFactory
12 | import org.rewedigital.katana.inject
13 | 
14 | /**
15 |  * @see FirstFragment
16 |  * @see SecondFragment
17 |  */
18 | class FragmentActivity : AppCompatActivity(), KatanaTrait {
19 | 
20 |     override val component: Component = Component(
21 |         modules = listOf(
22 |             ActivityModule(this),
23 |             FragmentFactoryModule,
24 |             FragmentActivityModule
25 |         )
26 |     )
27 | 
28 |     private val fragmentFactory by inject<KatanaFragmentFactory>()
29 | 
30 |     override fun onCreate(savedInstanceState: Bundle?) {
31 |         // Must be set **before** super call for Fragment instantiation after orientation change
32 |         supportFragmentManager.fragmentFactory = fragmentFactory
33 | 
34 |         super.onCreate(savedInstanceState)
35 | 
36 |         setContentView(R.layout.activity_fragment)
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Key.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | /**
 4 |  * Unique key per dependency declaration based either on the class or name of the dependency.
 5 |  */
 6 | @PublishedApi
 7 | internal sealed class Key {
 8 | 
 9 |     /**
10 |      * Optional additional key that is part of a key.
11 |      * A context key might be set for bindings inside a specific binding context which should be unique per context.
12 |      */
13 |     internal abstract val contextKey: Key?
14 | 
15 |     /**
16 |      * Optional increment which is required for multi bindings (set bindings) as a set for instance defines multiple
17 |      * declarations of the same type.
18 |      */
19 |     internal abstract val increment: Int?
20 | 
21 |     data class ClassKey<T>(
22 |         val clazz: Class<T>,
23 |         override val contextKey: Key? = null,
24 |         override val increment: Int? = null
25 |     ) : Key()
26 | 
27 |     data class NameKey(
28 |         val name: Any,
29 |         override val contextKey: Key? = null,
30 |         override val increment: Int? = null
31 |     ) : Key()
32 | 
33 |     companion object {
34 | 
35 |         fun <T> of(
36 |             clazz: Class<T>,
37 |             name: Any? = null,
38 |             contextKey: Key? = null,
39 |             increment: Int? = null
40 |         ): Key =
41 |             when (name) {
42 |                 null -> ClassKey(clazz = clazz, contextKey = contextKey, increment = increment)
43 |                 else -> NameKey(name = name, contextKey = contextKey, increment = increment)
44 |             }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/.idea/runConfigurations/Android_Example.xml:
--------------------------------------------------------------------------------
 1 | <component name="ProjectRunConfigurationManager">
 2 |   <configuration default="false" name="Android Example" type="AndroidRunConfigurationType" factoryName="Android App" activateToolWindowBeforeRun="false">
 3 |     <module name="katana.android-example" />
 4 |     <option name="DEPLOY" value="true" />
 5 |     <option name="DEPLOY_APK_FROM_BUNDLE" value="false" />
 6 |     <option name="DEPLOY_AS_INSTANT" value="false" />
 7 |     <option name="ARTIFACT_NAME" value="" />
 8 |     <option name="PM_INSTALL_OPTIONS" value="" />
 9 |     <option name="DYNAMIC_FEATURES_DISABLED_LIST" value="" />
10 |     <option name="ACTIVITY_EXTRA_FLAGS" value="" />
11 |     <option name="MODE" value="default_activity" />
12 |     <option name="CLEAR_LOGCAT" value="false" />
13 |     <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
14 |     <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
15 |     <option name="FORCE_STOP_RUNNING_APP" value="true" />
16 |     <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
17 |     <option name="DEBUGGER_TYPE" value="Java" />
18 |     <Java />
19 |     <Profilers>
20 |       <option name="ADVANCED_PROFILING_ENABLED" value="false" />
21 |       <option name="STARTUP_CPU_PROFILING_ENABLED" value="false" />
22 |       <option name="STARTUP_CPU_PROFILING_CONFIGURATION_NAME" value="Sample Java Methods" />
23 |     </Profilers>
24 |     <option name="DEEP_LINK" value="" />
25 |     <option name="ACTIVITY_CLASS" value="" />
26 |     <method v="2">
27 |       <option name="Android.Gradle.BeforeRunTask" enabled="true" />
28 |     </method>
29 |   </configuration>
30 | </component>


--------------------------------------------------------------------------------
/android-example/src/main/res/layout/activity_fragment.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:app="http://schemas.android.com/apk/res-auto"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent">
 7 | 
 8 |     <fragment
 9 |         android:id="@+id/firstFragment"
10 |         android:name="org.rewedigital.katana.android.example.fragment.view.FirstFragment"
11 |         android:layout_width="0dp"
12 |         android:layout_height="0dp"
13 |         app:layout_constraintEnd_toEndOf="parent"
14 |         app:layout_constraintHeight_default="percent"
15 |         app:layout_constraintHeight_percent=".5"
16 |         app:layout_constraintStart_toStartOf="parent"
17 |         app:layout_constraintTop_toTopOf="parent"
18 |         tools:layout="@layout/fragment_first" />
19 | 
20 |     <fragment
21 |         android:id="@+id/secondFragment"
22 |         android:name="org.rewedigital.katana.android.example.fragment.view.SecondFragment"
23 |         android:layout_width="0dp"
24 |         android:layout_height="0dp"
25 |         app:layout_constraintBottom_toBottomOf="parent"
26 |         app:layout_constraintEnd_toEndOf="parent"
27 |         app:layout_constraintHeight_default="percent"
28 |         app:layout_constraintHeight_percent=".5"
29 |         app:layout_constraintStart_toStartOf="parent"
30 |         app:layout_constraintTop_toBottomOf="@id/firstFragment"
31 |         tools:layout="@layout/fragment_second" />
32 | 
33 | </androidx.constraintlayout.widget.ConstraintLayout>
34 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/KatanaApp.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example
 2 | 
 3 | import android.app.Application
 4 | import android.os.StrictMode
 5 | import org.rewedigital.katana.Component
 6 | import org.rewedigital.katana.Katana
 7 | import org.rewedigital.katana.android.AndroidKatanaLogger
 8 | import org.rewedigital.katana.android.environment.AndroidEnvironmentContext
 9 | import org.rewedigital.katana.android.example.inject.AndroidModule
10 | import org.rewedigital.katana.android.modules.ApplicationModule
11 | 
12 | class KatanaApp : Application() {
13 | 
14 |     override fun onCreate() {
15 |         super.onCreate()
16 | 
17 |         //<editor-fold desc="Setup leak detection">
18 |         StrictMode.setVmPolicy(
19 |             StrictMode.VmPolicy.Builder()
20 |                 .detectActivityLeaks()
21 |                 .detectLeakedClosableObjects()
22 |                 .penaltyLog()
23 |                 .penaltyDeath()
24 |                 .build()
25 |         )
26 |         //</editor-fold>
27 | 
28 |         // Installing logger for Katana
29 |         Katana.logger = AndroidKatanaLogger
30 |         // Specify Android environment for optimized usage on Android
31 |         Katana.environmentContext = AndroidEnvironmentContext()
32 | 
33 |         applicationComponent = Component(
34 |             ApplicationModule(this),
35 |             AndroidModule
36 |         )
37 |     }
38 | 
39 |     companion object {
40 |         // The application component is a singleton and can be accessed by other components via
41 |         // KatanaApp.applicationComponent.
42 |         lateinit var applicationComponent: Component
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/drawable/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
 1 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
 2 |         android:width="108dp"
 3 |         android:height="108dp"
 4 |         android:viewportWidth="28.574999"
 5 |         android:viewportHeight="28.575">
 6 |     <path
 7 |             android:pathData="M19.1285,14.4575 L15.0327,18.5539 20.8184,28.575L28.575,28.575L28.575,23.8125 28.575,19.9114Z"
 8 |             android:strokeAlpha="1"
 9 |             android:strokeLineJoin="miter"
10 |             android:strokeWidth="0.99999994"
11 |             android:fillColor="#000000"
12 |             android:strokeColor="#00000000"
13 |             android:fillAlpha="0.15686275"
14 |             android:strokeLineCap="butt"/>
15 |     <path
16 |             android:pathData="M9.0728,9.0728L11.7233,11.8013C11.3948,12.2346 11.0291,12.9158 11.0329,13.4302L14.6518,17.0486C14.8045,17.2017 14.8045,17.4499 14.6518,17.6031L14.366,17.8878L15.0327,18.5539L19.1285,14.4575L18.4624,13.7914L18.1777,14.0761C18.0246,14.2293 17.7768,14.2293 17.6232,14.0761L14.0053,10.4583C13.491,10.4545 12.8325,10.8175 12.3992,11.1456L10.2965,9.0728L9.0728,9.0728zM9.4139,10.2846C8.918,11.0242 8.599,11.4869 8.599,11.9367C8.599,12.3866 8.9636,12.7512 9.4139,12.7512C9.8638,12.7512 10.2278,12.3866 10.2278,11.9367C10.2278,11.4869 9.9097,11.0242 9.4139,10.2846zM17.8496,16.4083L16.8992,17.3586L17.6423,18.1023C17.795,18.2549 17.7955,18.5026 17.6423,18.6557L17.3008,18.9973L17.7891,19.5022L19.976,17.2982L19.4882,16.8103L19.1466,17.1519C18.994,17.3046 18.7453,17.3046 18.5927,17.1519L17.8496,16.4083z"
17 |             android:strokeWidth="1.79166663"
18 |             android:fillColor="#ffffff"
19 |             android:fillType="evenOdd"/>
20 | </vector>
21 | 


--------------------------------------------------------------------------------
/.idea/runConfigurations/Android_Example__Fragment_.xml:
--------------------------------------------------------------------------------
 1 | <component name="ProjectRunConfigurationManager">
 2 |   <configuration default="false" name="Android Example (Fragment)" type="AndroidRunConfigurationType" factoryName="Android App" activateToolWindowBeforeRun="false">
 3 |     <module name="katana.android-example" />
 4 |     <option name="DEPLOY" value="true" />
 5 |     <option name="DEPLOY_APK_FROM_BUNDLE" value="false" />
 6 |     <option name="DEPLOY_AS_INSTANT" value="false" />
 7 |     <option name="ARTIFACT_NAME" value="" />
 8 |     <option name="PM_INSTALL_OPTIONS" value="" />
 9 |     <option name="DYNAMIC_FEATURES_DISABLED_LIST" value="" />
10 |     <option name="ACTIVITY_EXTRA_FLAGS" value="" />
11 |     <option name="MODE" value="default_activity" />
12 |     <option name="CLEAR_LOGCAT" value="false" />
13 |     <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
14 |     <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
15 |     <option name="FORCE_STOP_RUNNING_APP" value="true" />
16 |     <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
17 |     <option name="DEBUGGER_TYPE" value="Java" />
18 |     <Java />
19 |     <Profilers>
20 |       <option name="ADVANCED_PROFILING_ENABLED" value="false" />
21 |       <option name="STARTUP_CPU_PROFILING_ENABLED" value="false" />
22 |       <option name="STARTUP_CPU_PROFILING_CONFIGURATION_NAME" value="Sample Java Methods" />
23 |     </Profilers>
24 |     <option name="DEEP_LINK" value="" />
25 |     <option name="ACTIVITY_CLASS" value="org.rewedigital.katana.android.example.fragment.view.FragmentActivity" />
26 |     <method v="2">
27 |       <option name="Android.Gradle.BeforeRunTask" enabled="true" />
28 |     </method>
29 |   </configuration>
30 | </component>


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/AliasTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBe
 4 | import org.rewedigital.katana.dsl.alias
 5 | import org.rewedigital.katana.dsl.singleton
 6 | import org.spekframework.spek2.Spek
 7 | import org.spekframework.spek2.style.specification.describe
 8 | 
 9 | object AliasTests : Spek(
10 |     {
11 |         describe("Alias bindings") {
12 | 
13 |             it("should provide aliases for class bindings") {
14 | 
15 |                 val module = Module {
16 | 
17 |                     singleton { MyComponentA() }
18 | 
19 |                     alias<MyComponent, MyComponentA>()
20 |                 }
21 | 
22 |                 val component = Component(module)
23 | 
24 |                 val myComponentA: MyComponentA by component.inject()
25 |                 val myComponent: MyComponent by component.inject()
26 | 
27 |                 myComponent shouldBe myComponentA
28 |             }
29 | 
30 |             it("should provide aliases for named bindings") {
31 | 
32 |                 val module = Module {
33 | 
34 |                     singleton(name = "original name") { MyComponentA() }
35 | 
36 |                     alias<MyComponent, MyComponentA>(
37 |                         name = "alias name",
38 |                         originalName = "original name"
39 |                     )
40 |                 }
41 | 
42 |                 val component = Component(module)
43 | 
44 |                 val myComponentA: MyComponentA by component.inject(name = "original name")
45 |                 val myComponent: MyComponent by component.inject(name = "alias name")
46 | 
47 |                 myComponent shouldBe myComponentA
48 |             }
49 |         }
50 |     })
51 | 


--------------------------------------------------------------------------------
/android/src/main/kotlin/org/rewedigital/katana/android/environment/AndroidEnvironmentContext.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.environment
 2 | 
 3 | import androidx.collection.ArrayMap
 4 | import org.rewedigital.katana.android.environment.AndroidEnvironmentContext.Profile.MEMORY
 5 | import org.rewedigital.katana.android.environment.AndroidEnvironmentContext.Profile.SPEED
 6 | import org.rewedigital.katana.environment.EnvironmentContext
 7 | import org.rewedigital.katana.environment.MapFactory
 8 | 
 9 | class AndroidEnvironmentContext(private val profile: Profile = MEMORY) : EnvironmentContext {
10 | 
11 |     enum class Profile {
12 |         /**
13 |          * Optimized on low memory usage at the cost of speed.
14 |          */
15 |         MEMORY,
16 | 
17 |         /**
18 |          * Optimized on speed at the cost of memory usage.
19 |          */
20 |         SPEED
21 |     }
22 | 
23 |     private class AndroidMemoryProfileMapFactory : MapFactory {
24 | 
25 |         override fun <K, V> create(initialCapacity: Int?): MutableMap<K, V> =
26 |             if (initialCapacity == null) {
27 |                 ArrayMap()
28 |             } else {
29 |                 ArrayMap(initialCapacity)
30 |             }
31 |     }
32 | 
33 |     private class AndroidSpeedProfileMapFactory : MapFactory {
34 | 
35 |         override fun <K, V> create(initialCapacity: Int?): MutableMap<K, V> =
36 |             if (initialCapacity == null) {
37 |                 HashMap()
38 |             } else {
39 |                 HashMap(initialCapacity)
40 |             }
41 |     }
42 | 
43 |     override fun mapFactory(): MapFactory =
44 |         when (profile) {
45 |             MEMORY -> AndroidMemoryProfileMapFactory()
46 |             SPEED -> AndroidSpeedProfileMapFactory()
47 |         }
48 | }
49 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/TypeErasureTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBeEqualTo
 4 | import org.amshove.kluent.shouldThrow
 5 | import org.rewedigital.katana.dsl.factory
 6 | import org.spekframework.spek2.Spek
 7 | import org.spekframework.spek2.style.specification.describe
 8 | 
 9 | object TypeErasureTests : Spek(
10 |     {
11 |         describe("Modules with type erasure") {
12 | 
13 |             it("should throw exception when type erasure kicks in") {
14 |                 val fn = {
15 |                     Module {
16 | 
17 |                         factory {
18 |                             MyComponentB(1337)
19 |                         }
20 | 
21 |                         factory {
22 |                             MyComponentB("Hello world")
23 |                         }
24 |                     }
25 |                 }
26 | 
27 |                 fn shouldThrow OverrideException::class
28 |             }
29 | 
30 |             it("should work when unique names have been specified") {
31 |                 val module = Module {
32 | 
33 |                     factory("int") {
34 |                         MyComponentB(1337)
35 |                     }
36 | 
37 |                     factory("string") {
38 |                         MyComponentB("Hello world")
39 |                     }
40 |                 }
41 | 
42 |                 val component = Component(module)
43 | 
44 |                 val myComponent1: MyComponentB<Int> by component.inject("int")
45 |                 val myComponent2: MyComponentB<String> by component.inject("string")
46 | 
47 |                 myComponent1.value shouldBeEqualTo 1337
48 |                 myComponent2.value shouldBeEqualTo "Hello world"
49 |             }
50 |         }
51 |     })
52 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/KatanaTrait.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | /**
 4 |  * Helper trait for simplifying injection syntax.
 5 |  *
 6 |  * Can be applied to a class which holds a [Component].
 7 |  * The extension functions [inject], [injectNow] and [canInject] can then be used instead of explicitly referencing
 8 |  * `component` every time.
 9 |  *
10 |  * ```
11 |  * class Example : KatanaTrait {
12 |  *     override val component = Component(module)
13 |  *     // We don't have to explicitly reference component like component.inject()
14 |  *     private val myDependency: MyDependency by inject()
15 |  * }
16 |  * ```
17 |  */
18 | interface KatanaTrait {
19 |     val component: Component
20 | }
21 | 
22 | /**
23 |  * @see Component.inject
24 |  */
25 | inline fun <reified T> KatanaTrait.inject(name: Any? = null) =
26 |     withComponent { inject<T>(name) }
27 | 
28 | /**
29 |  * @see Component.injectNow
30 |  *
31 |  * TODO: Rename to get()?
32 |  */
33 | inline fun <reified T> KatanaTrait.injectNow(name: Any? = null) =
34 |     withComponent { injectNow<T>(name) }
35 | 
36 | /**
37 |  * @see Component.canInject
38 |  */
39 | inline fun <reified T> KatanaTrait.canInject(name: Any? = null) =
40 |     withComponent { canInject<T>(name) }
41 | 
42 | @Suppress("SENSELESS_COMPARISON")
43 | @PublishedApi
44 | internal fun <R> KatanaTrait.withComponent(body: Component.() -> R) =
45 | // Despite the non-null type the `component` can be null if the above extension functions are used before the
46 | // `component` property was initialized.
47 |     if (component == null) {
48 |         throw ComponentNotInitializedException("component is null! Make sure to use KatanaTrait's extension functions *after* component property was initialized.")
49 |     } else {
50 |         body.invoke(component)
51 |     }
52 | 


--------------------------------------------------------------------------------
/android-example/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |           xmlns:tools="http://schemas.android.com/tools"
 4 |           package="org.rewedigital.katana.android.example">
 5 | 
 6 |     <uses-permission android:name="android.permission.INTERNET" />
 7 | 
 8 |     <application
 9 |             android:name=".KatanaApp"
10 |             android:allowBackup="false"
11 |             android:icon="@mipmap/ic_launcher"
12 |             android:label="@string/app_name"
13 |             android:roundIcon="@mipmap/ic_launcher_round"
14 |             android:theme="@style/AppTheme"
15 |             tools:ignore="GoogleAppIndexingWarning,MissingApplicationIcon">
16 | 
17 |         <activity
18 |                 android:name=".main.view.MainActivity"
19 |                 android:taskAffinity="org.rewedigital.katana.android.example.main.view.MainActivity">
20 | 
21 |             <intent-filter>
22 |                 <action android:name="android.intent.action.MAIN" />
23 | 
24 |                 <category android:name="android.intent.category.LAUNCHER" />
25 |                 <category android:name="android.intent.category.DEFAULT"/>
26 |             </intent-filter>
27 | 
28 |         </activity>
29 | 
30 |         <activity
31 |                 android:name=".fragment.view.FragmentActivity"
32 |                 android:label="@string/fragment_example"
33 |                 android:taskAffinity="org.rewedigital.katana.android.example.fragment.view.FragmentActivity">
34 | 
35 |             <intent-filter>
36 |                 <action android:name="android.intent.action.MAIN" />
37 |                 <category android:name="android.intent.category.LAUNCHER" />
38 |             </intent-filter>
39 | 
40 |         </activity>
41 | 
42 |     </application>
43 | 
44 | </manifest>
45 | 


--------------------------------------------------------------------------------
/android/src/main/kotlin/org/rewedigital/katana/android/fragment/KatanaFragmentDelegate.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.fragment
 2 | 
 3 | import android.app.Activity
 4 | import android.os.Bundle
 5 | import androidx.fragment.app.Fragment
 6 | 
 7 | /**
 8 |  * Usually Katana components of Fragments depend on components of the parent Activity.
 9 |  *
10 |  * Since Fragments are instantiated **before** Activities, the component initialization must be
11 |  * delayed until the Activity was created.
12 |  *
13 |  * The delegate simplifies this procedure a bit. A delegate is for example created in the init block
14 |  * of the Fragment via [fragmentDelegate]. [onActivityCreated] of the delegate must be called in
15 |  * [Fragment.onActivityCreated]. The lambda passed to the delegate is called when [onActivityCreated]
16 |  * was called. Inside the lambda component initialization and dependency injection should be
17 |  * performed.
18 |  *
19 |  * @see fragmentDelegate
20 |  * @see KatanaFragment
21 |  */
22 | class KatanaFragmentDelegate<T : Fragment>(
23 |     private val fragment: T,
24 |     private val onInject: T.(activity: Activity, savedInstanceState: Bundle?) -> Unit
25 | ) {
26 | 
27 |     /**
28 |      * Must be called in [Fragment.onActivityCreated] of Fragment associated with this delegate.
29 |      *
30 |      * @param savedInstanceState Saved state as passed to [Fragment.onActivityCreated].
31 |      */
32 |     fun onActivityCreated(savedInstanceState: Bundle?) {
33 |         fragment.activity?.let { activity ->
34 |             fragment.onInject(activity, savedInstanceState)
35 |         } ?: throw IllegalStateException("Activity is null. Was delegate called in onActivityCreated() of Fragment?")
36 |     }
37 | }
38 | 
39 | fun <T : Fragment> T.fragmentDelegate(onInject: T.(activity: Activity, savedInstanceState: Bundle?) -> Unit) =
40 |     KatanaFragmentDelegate(
41 |         fragment = this,
42 |         onInject = onInject
43 |     )
44 | 


--------------------------------------------------------------------------------
/speed-comparison/README.md:
--------------------------------------------------------------------------------
 1 | Speed comparison of the three DI libraries Katana, [Koin](https://github.com/InsertKoinIO/koin) and [Kodein](https://github.com/Kodein-Framework/Kodein-DI).
 2 | 
 3 | Also see this independent [comparison](https://github.com/Sloy/android-dependency-injection-performance).
 4 | 
 5 | ## Test setup
 6 | 
 7 | Please have a look at the source code. The test is divided into the two blocks *setup* and *execution*. *Setup* tests 
 8 | how fast the test subject is in setting up the dependency injection (creating modules, bindings, etc.) and *execution*
 9 | tests the actual injection. The test collects the average and median time in nanoseconds of 1,000,000 iterations of
10 | each block.
11 | 
12 | ### Library versions
13 | 
14 | | Library | Version |
15 | | ------- | ------- |
16 | | Katana  | 1.7.1   |
17 | | Koin    | 2.0.1   |
18 | | Kodein  | 6.3.3   |
19 | 
20 | For fairness towards Kodein the [erased](http://kodein.org/Kodein-DI/?6.0.1/getting-started#_flavour) version of Kodein
21 | was used for this comparison. It should be faster since it doesn't use reflection.
22 | 
23 | ## Test environment
24 | 
25 | The test has been performed on a 2017 MacBook Pro with a 3,1 GHz Intel Core i7 CPU, 16 GB RAM, macOS Mojave 10.14.6 and
26 | Java 1.8.0_222.
27 | 
28 | ## Results
29 | 
30 | All times in nanoseconds.
31 | 
32 | | Library | Setup (average) | Setup (median) | Execution (average) | Execution (median) |
33 | | ------- | ---------------:| --------------:| -------------------:| ------------------:|
34 | | Katana  |      793.377251 |          527.0 |          259.320590 |              181.0 |
35 | | Koin    |      969.294944 |          509.0 |          370.726363 |              254.0 |
36 | | Kodein  |     1629.850542 |          951.0 |          809.621470 |              566.0 |
37 | 
38 | ## How to build and run comparison
39 | 
40 | From the root folder of the project run:
41 | 
42 | ```
43 | ./gradlew :speed-comparison:build
44 | java -jar ./speed-comparison/build/libs/speed-comparison-fat.jar
45 | ```
46 | 


--------------------------------------------------------------------------------
/android/src/main/kotlin/org/rewedigital/katana/android/modules/AndroidModules.kt:
--------------------------------------------------------------------------------
 1 | @file:Suppress("FunctionName")
 2 | 
 3 | package org.rewedigital.katana.android.modules
 4 | 
 5 | import android.app.Activity
 6 | import android.app.Application
 7 | import android.content.Context
 8 | import androidx.fragment.app.Fragment
 9 | import org.rewedigital.katana.Module
10 | import org.rewedigital.katana.dsl.factory
11 | import org.rewedigital.katana.dsl.singleton
12 | 
13 | const val APPLICATION = "APPLICATION"
14 | const val APPLICATION_CONTEXT = "APPLICATION_CONTEXT"
15 | 
16 | /**
17 |  * Provides a named binding of `Application` as `APPLICATION` and of the application `Context` as `APPLICATION_CONTEXT`.
18 |  */
19 | fun ApplicationModule(app: Application) = Module("ApplicationModule") {
20 | 
21 |     singleton(name = APPLICATION) { app }
22 | 
23 |     singleton<Context>(name = APPLICATION_CONTEXT) { app }
24 | }
25 | 
26 | const val ACTIVITY = "ACTIVITY"
27 | const val ACTIVITY_CONTEXT = "ACTIVITY_CONTEXT"
28 | 
29 | /**
30 |  * Provides a named binding of `Activity` as `ACTIVITY` and of the Activity's `Context` as `ACTIVITY_CONTEXT`.
31 |  *
32 |  * **Note:** This module should only be referenced from a [Component][org.rewedigital.katana.Component] located in an
33 |  * `Activity` or else Activity/memory leaks might be introduced!
34 |  */
35 | fun ActivityModule(activity: Activity) = Module("ActivityModule") {
36 | 
37 |     singleton(name = ACTIVITY) { activity }
38 | 
39 |     singleton<Context>(name = ACTIVITY_CONTEXT) { activity }
40 | }
41 | 
42 | const val SUPPORT_FRAGMENT = "SUPPORT_FRAGMENT"
43 | const val SUPPORT_FRAGMENT_CONTEXT = "SUPPORT_FRAGMENT_CONTEXT"
44 | 
45 | /**
46 |  * Provides a named binding of `Fragment` as `SUPPORT_FRAGMENT` and of the Fragment's `Context` as
47 |  * `SUPPORT_FRAGMENT_CONTEXT`. Note that the Fragment's Context may be `null`.
48 |  */
49 | fun SupportFragmentModule(fragment: Fragment) = Module("SupportFragmentModule") {
50 | 
51 |     singleton(name = SUPPORT_FRAGMENT) { fragment }
52 | 
53 |     factory(name = SUPPORT_FRAGMENT_CONTEXT) { fragment.context }
54 | }
55 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/Module.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import java.util.concurrent.atomic.AtomicInteger
 4 | 
 5 | /**
 6 |  * Describes **how** dependencies are resolved by providing dependency declarations via `factory`, `singleton`, etc.
 7 |  *
 8 |  * A module is not responsible for holding instances of dependencies or for performing actual injection. It can be
 9 |  * interpreted as a blueprint of dependency declarations which is applied to a [Component]. Therefore one module might
10 |  * be referenced by multiple components.
11 |  *
12 |  * Each module should represent a logical unit. For instance there should be separate modules for each functionality
13 |  * of your application.
14 |  *
15 |  * @param name Optional name. Is used for exception messages and may improve debugging DI-related issues.
16 |  * @param includes Collection of modules included by this module.
17 |  *
18 |  * @see Component
19 |  */
20 | class Module private constructor(
21 |     internal val id: Int,
22 |     internal val name: String?,
23 |     internal val includes: Iterable<Module>
24 | ) {
25 |     private val bindingContext = ModuleBindingContext(this)
26 | 
27 |     /**
28 |      * Creates a module (with an optional name).
29 |      *
30 |      * @param name Optional name. Is used for exception messages and may improve debugging DI-related issues.
31 |      * @param includes Collection of modules included by this module.
32 |      *
33 |      * @see Module
34 |      */
35 |     constructor(
36 |         name: String? = null,
37 |         includes: Iterable<Module> = emptyList(),
38 |         declarations: ModuleBindingContext.() -> Unit = {}
39 |     ) : this(
40 |         id = ModuleIdProvider.id,
41 |         name = name,
42 |         includes = includes
43 |     ) {
44 |         declarations.invoke(bindingContext)
45 |     }
46 | 
47 |     internal val declarations = Katana.environmentContext.mapFactory().create<Key, Declaration<*>>()
48 | }
49 | 
50 | private object ModuleIdProvider {
51 | 
52 |     private val nextId = AtomicInteger()
53 | 
54 |     val id
55 |         get() = nextId.getAndIncrement()
56 | }
57 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/KatanaTraitTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBeEqualTo
 4 | import org.amshove.kluent.shouldBeInstanceOf
 5 | import org.amshove.kluent.shouldThrow
 6 | import org.rewedigital.katana.dsl.singleton
 7 | import org.spekframework.spek2.Spek
 8 | import org.spekframework.spek2.style.specification.describe
 9 | 
10 | object KatanaTraitTests : Spek(
11 |     {
12 |         val module = Module {
13 |             singleton<MyComponent> { MyComponentA() }
14 |         }
15 | 
16 |         class TestKatanaTrait : KatanaTrait {
17 | 
18 |             override val component = Component(module)
19 | 
20 |             val myComponent by inject<MyComponent>()
21 | 
22 |             val myComponent2 = injectNow<MyComponent>()
23 |         }
24 | 
25 |         val trait by memoized { TestKatanaTrait() }
26 | 
27 |         @Suppress("unused")
28 |         class DelegateBeforeInitialization : KatanaTrait {
29 | 
30 |             val myComponent by inject<MyComponent>()
31 | 
32 |             override val component = Component(module)
33 |         }
34 | 
35 |         describe("KatanaTrait") {
36 | 
37 |             it("should throw meaningful exception when component was not initialized") {
38 |                 {
39 |                     DelegateBeforeInitialization()
40 |                 }.shouldThrow(ComponentNotInitializedException::class)
41 |             }
42 | 
43 |             context("injectNow") {
44 | 
45 |                 it("should inject dependency") {
46 |                     trait.myComponent shouldBeInstanceOf MyComponentA::class.java
47 |                 }
48 |             }
49 | 
50 |             context("inject") {
51 | 
52 |                 it("should inject dependency") {
53 |                     trait.myComponent2 shouldBeInstanceOf MyComponentA::class.java
54 |                 }
55 |             }
56 | 
57 |             context("canInject") {
58 | 
59 |                 it("should work") {
60 |                     trait.canInject<MyComponent>() shouldBeEqualTo true
61 |                     trait.canInject<String>() shouldBeEqualTo false
62 |                 }
63 |             }
64 |         }
65 |     })
66 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/dsl/ProviderDsl.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.dsl
 2 | 
 3 | import org.rewedigital.katana.Component
 4 | import org.rewedigital.katana.ComponentContext
 5 | import org.rewedigital.katana.InjectionException
 6 | 
 7 | /**
 8 |  * Provides syntax for injecting transitive dependencies via [get], [getOrNull] or [provider] within the provider body.
 9 |  *
10 |  * @see get
11 |  * @see getOrNull
12 |  * @see provider
13 |  */
14 | @ModuleDslMarker
15 | class ProviderDsl(val context: ComponentContext)
16 | 
17 | /**
18 |  * Provides a dependency which is declared in the current context (total set of modules of the
19 |  * current component). Allows injection of transitive dependencies within a module.
20 |  *
21 |  * @param name Optional name of binding
22 |  * @return Requested dependency
23 |  * @throws InjectionException if no binding for dependency was found
24 |  * @see getOrNull
25 |  * @see provider
26 |  */
27 | inline fun <reified T> ProviderDsl.get(name: Any? = null) =
28 |     context.injectNow<T>(name = name, internal = true)
29 | 
30 | /**
31 |  * Provides an optional dependency which might be declared in the current context.
32 |  *
33 |  * @param name Optional name of binding
34 |  * @return Requested dependency or `null` if no binding for dependency was found
35 |  * @see get
36 |  */
37 | inline fun <reified T> ProviderDsl.getOrNull(name: Any? = null) =
38 |     context.injectNowOrNull<T>(name = name, internal = true)
39 | 
40 | /**
41 |  * Returns a function that when invoked provides a (new) instance of requested dependency.
42 |  *
43 |  * For dependencies declared as [singleton] the function will return the **same** instance on every invocation!
44 |  * Basically this is [get] wrapped in a lambda.
45 |  *
46 |  * @param name Optional name of binding
47 |  * @throws InjectionException on invocation of provider function if no binding for dependency was found
48 |  * @see get
49 |  */
50 | inline fun <reified T> ProviderDsl.provider(name: Any? = null): () -> T = { get(name) }
51 | 
52 | /**
53 |  * Special property for providing the [Component] that this [Module] is associated with.
54 |  */
55 | val ProviderDsl.component: Component
56 |     get() = context.thisComponent
57 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/presenter/MainPresenter.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.presenter
 2 | 
 3 | import android.util.Log
 4 | import kotlinx.coroutines.*
 5 | import org.jetbrains.anko.coroutines.experimental.asReference
 6 | import org.rewedigital.katana.android.example.main.interactor.MainInteractor
 7 | import org.rewedigital.katana.android.example.main.navigator.MainNavigator
 8 | import org.rewedigital.katana.android.example.main.view.MainView
 9 | 
10 | interface MainPresenter {
11 | 
12 |     fun onCreate()
13 | 
14 |     fun onDestroy()
15 | 
16 |     fun onButtonClick(id: String)
17 | 
18 |     fun onRemoteButtonClick()
19 | 
20 |     fun onExitButtonClick()
21 | 
22 |     fun onDialogOkClick()
23 | }
24 | 
25 | class MainPresenterImpl(
26 |     private val view: MainView,
27 |     private val interactor: MainInteractor,
28 |     private val navigator: MainNavigator
29 | ) : MainPresenter,
30 |     CoroutineScope {
31 | 
32 |     override val coroutineContext = Dispatchers.Main + Job()
33 | 
34 |     override fun onCreate() {
35 |         interactor.fetchButtons().forEach { button ->
36 |             view.addButton(button.id, button.label)
37 |         }
38 |     }
39 | 
40 |     override fun onDestroy() {
41 |         coroutineContext.cancel()
42 |     }
43 | 
44 |     override fun onButtonClick(id: String) {
45 |         interactor.findButtonById(id)?.let { button ->
46 |             view.showToast(button.message)
47 |         }
48 |     }
49 | 
50 |     override fun onRemoteButtonClick() {
51 |         val ref = asReference()
52 |         launch {
53 |             try {
54 |                 ref().view.showDialog()
55 |                 val posts = ref().interactor.fetchPosts()
56 |                 ref().view.setDialogResult(posts[0].body)
57 |             } catch (e: Exception) {
58 |                 Log.e(TAG, "Could not load posts", e)
59 |             }
60 |         }
61 |     }
62 | 
63 |     override fun onExitButtonClick() {
64 |         navigator.exit()
65 |     }
66 | 
67 |     override fun onDialogOkClick() {
68 |         view.dismissDialog()
69 |     }
70 | 
71 |     private companion object {
72 |         private const val TAG = "MainPresenter"
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/ComponentBuilderTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBeEqualTo
 4 | import org.rewedigital.katana.dsl.factory
 5 | import org.spekframework.spek2.Spek
 6 | import org.spekframework.spek2.style.specification.describe
 7 | 
 8 | object ComponentBuilderTests : Spek(
 9 |     {
10 |         describe("Component Builder") {
11 | 
12 |             it("should build component with add functions") {
13 |                 val module1 = Module {
14 |                     factory("TEST") { "Hello" }
15 |                 }
16 | 
17 |                 val component1 = Component(module1)
18 | 
19 |                 val module2 = Module {
20 |                     factory("TEST2") { "World" }
21 |                 }
22 | 
23 |                 val component2 = Component.Builder()
24 |                     .addModule(module2)
25 |                     .addDependsOn(component1)
26 |                     .build()
27 | 
28 |                 component2.injectNow<String>("TEST") shouldBeEqualTo "Hello"
29 |                 component2.injectNow<String>("TEST2") shouldBeEqualTo "World"
30 |             }
31 | 
32 |             it("should build component with set functions") {
33 |                 val module1 = Module {
34 |                     factory("TEST") { "Hello" }
35 |                 }
36 | 
37 |                 val component1 = Component(module1)
38 | 
39 |                 val module2 = Module {
40 |                     factory("TEST2") { "World" }
41 |                 }
42 | 
43 |                 var component2 = Component.Builder()
44 |                     .setModules(module2)
45 |                     .setDependsOn(component1)
46 |                     .build()
47 | 
48 |                 component2.injectNow<String>("TEST") shouldBeEqualTo "Hello"
49 |                 component2.injectNow<String>("TEST2") shouldBeEqualTo "World"
50 | 
51 |                 component2 = Component.Builder()
52 |                     .setModules(listOf(module2))
53 |                     .setDependsOn(listOf(component1))
54 |                     .build()
55 | 
56 |                 component2.injectNow<String>("TEST") shouldBeEqualTo "Hello"
57 |                 component2.injectNow<String>("TEST2") shouldBeEqualTo "World"
58 |             }
59 |         }
60 |     })
61 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/MainModule.kt:
--------------------------------------------------------------------------------
 1 | @file:Suppress("FunctionName")
 2 | 
 3 | package org.rewedigital.katana.android.example.main
 4 | 
 5 | import android.content.Context
 6 | import org.rewedigital.katana.Module
 7 | import org.rewedigital.katana.android.example.main.interactor.MainInteractor
 8 | import org.rewedigital.katana.android.example.main.interactor.MainInteractorImpl
 9 | import org.rewedigital.katana.android.example.main.mapper.ButtonMapper
10 | import org.rewedigital.katana.android.example.main.mapper.ButtonMapperImpl
11 | import org.rewedigital.katana.android.example.main.navigator.MainNavigator
12 | import org.rewedigital.katana.android.example.main.navigator.MainNavigatorImpl
13 | import org.rewedigital.katana.android.example.main.presenter.MainPresenter
14 | import org.rewedigital.katana.android.example.main.presenter.MainPresenterImpl
15 | import org.rewedigital.katana.android.example.main.repository.ButtonRepository
16 | import org.rewedigital.katana.android.example.main.repository.ButtonRepositoryImpl
17 | import org.rewedigital.katana.android.example.main.view.MainActivity
18 | import org.rewedigital.katana.android.example.main.view.MainView
19 | import org.rewedigital.katana.android.modules.ACTIVITY
20 | import org.rewedigital.katana.android.modules.ACTIVITY_CONTEXT
21 | import org.rewedigital.katana.dsl.get
22 | import org.rewedigital.katana.dsl.singleton
23 | 
24 | /**
25 |  * This module demonstrates how the current [Context] can be injected safely.
26 |  * In order for this to work without introducing leaks the module must be installed in a
27 |  * [org.rewedigital.katana.Component] which is *only* referenced from the same Activity that
28 |  * created the component.
29 |  *
30 |  * @see MainActivity
31 |  * @see ButtonMapper
32 |  */
33 | fun MainModule(activity: MainActivity) = Module {
34 | 
35 |     singleton<ButtonMapper> { ButtonMapperImpl(get(ACTIVITY_CONTEXT)) }
36 | 
37 |     singleton<ButtonRepository> { ButtonRepositoryImpl() }
38 | 
39 |     singleton<MainView> { activity }
40 | 
41 |     singleton<MainPresenter> { MainPresenterImpl(get(), get(), get()) }
42 | 
43 |     singleton<MainInteractor> { MainInteractorImpl(get(), get(), get()) }
44 | 
45 |     singleton<MainNavigator> { MainNavigatorImpl(get(ACTIVITY)) }
46 | }
47 | 


--------------------------------------------------------------------------------
/android-example/src/androidTest/kotlin/org/rewedigital/katana/android/example/main/MainEspressoTest.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main
 2 | 
 3 | import androidx.test.espresso.Espresso.onView
 4 | import androidx.test.espresso.IdlingRegistry
 5 | import androidx.test.espresso.action.ViewActions
 6 | import androidx.test.espresso.assertion.ViewAssertions.matches
 7 | import androidx.test.espresso.idling.CountingIdlingResource
 8 | import androidx.test.espresso.matcher.ViewMatchers.withId
 9 | import androidx.test.espresso.matcher.ViewMatchers.withText
10 | import androidx.test.ext.junit.runners.AndroidJUnit4
11 | import androidx.test.filters.LargeTest
12 | import androidx.test.rule.ActivityTestRule
13 | import org.junit.Rule
14 | import org.junit.Test
15 | import org.junit.runner.RunWith
16 | import org.rewedigital.katana.android.example.R
17 | import org.rewedigital.katana.android.example.main.view.MainActivity
18 | 
19 | @RunWith(AndroidJUnit4::class)
20 | @LargeTest
21 | /**
22 |  * This Espresso test showcases how Katana modules can be overwritten/replaced for UI tests with
23 |  * mock/test variants. Instead of an actual network operation, static mock data is returned which
24 |  * makes the test stable and predictable.
25 |  *
26 |  * @see org.rewedigital.katana.android.example.remote.TestJsonPlaceholderRepository
27 |  * @see org.rewedigital.katana.android.example.remote.JsonPlaceholderApiSuccessMock
28 |  */
29 | class MainEspressoTest {
30 | 
31 |     init {
32 |         val repositoryIdlingResource = CountingIdlingResource("JsonPlaceholderRepository")
33 | 
34 |         // Overwrite modules with mock implementation
35 |         Modules.modules = listOf(
36 |             TestSuccessApiMockModule,
37 |             TestRepositoryModule(repositoryIdlingResource)
38 |         )
39 | 
40 |         IdlingRegistry.getInstance().register(repositoryIdlingResource)
41 |     }
42 | 
43 |     @get:Rule
44 |     val activityRule = ActivityTestRule(MainActivity::class.java)
45 | 
46 |     @Test
47 |     fun testRemote() {
48 |         onView(withText("Remote")).perform(ViewActions.click())
49 |         onView(withId(R.id.textView)).check(matches(withText("Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")))
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/android-example/src/main/res/layout/fragment_second.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:app="http://schemas.android.com/apk/res-auto"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent">
 7 | 
 8 |     <TextView
 9 |         android:id="@+id/textView"
10 |         android:layout_width="wrap_content"
11 |         android:layout_height="wrap_content"
12 |         android:layout_marginBottom="8dp"
13 |         app:layout_constraintBottom_toTopOf="@+id/editText"
14 |         app:layout_constraintEnd_toEndOf="parent"
15 |         app:layout_constraintHorizontal_bias="0.5"
16 |         app:layout_constraintStart_toStartOf="parent"
17 |         app:layout_constraintTop_toTopOf="parent"
18 |         app:layout_constraintVertical_chainStyle="packed"
19 |         tools:text="Second fragment" />
20 | 
21 |     <EditText
22 |         android:id="@+id/editText"
23 |         android:layout_width="wrap_content"
24 |         android:layout_height="wrap_content"
25 |         android:layout_marginStart="8dp"
26 |         android:ems="10"
27 |         android:hint="Enter some text"
28 |         android:inputType="textPersonName"
29 |         app:layout_constraintBottom_toBottomOf="parent"
30 |         app:layout_constraintEnd_toStartOf="@+id/button"
31 |         app:layout_constraintHorizontal_bias="0.5"
32 |         app:layout_constraintHorizontal_chainStyle="packed"
33 |         app:layout_constraintStart_toStartOf="parent"
34 |         app:layout_constraintTop_toBottomOf="@+id/textView" />
35 | 
36 |     <Button
37 |         android:id="@+id/button"
38 |         android:layout_width="wrap_content"
39 |         android:layout_height="wrap_content"
40 |         android:layout_marginStart="8dp"
41 |         android:layout_marginEnd="8dp"
42 |         android:text="Save"
43 |         app:layout_constraintBottom_toBottomOf="@+id/editText"
44 |         app:layout_constraintEnd_toEndOf="parent"
45 |         app:layout_constraintHorizontal_bias="0.5"
46 |         app:layout_constraintStart_toEndOf="@+id/editText"
47 |         app:layout_constraintTop_toTopOf="@+id/editText" />
48 | 
49 | </androidx.constraintlayout.widget.ConstraintLayout>
50 | 


--------------------------------------------------------------------------------
/speed-comparison/src/main/kotlin/org/rewedigital/katana/comparison/Comparison.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.comparison
 2 | 
 3 | import org.nield.kotlinstatistics.median
 4 | 
 5 | const val ITERATIONS = 1_000_000
 6 | 
 7 | data class Timings(val setup: Long,
 8 |                    val execution: Long)
 9 | 
10 | data class Results(val setupAverage: Double,
11 |                    val setupMedian: Double,
12 |                    val executionAverage: Double,
13 |                    val executionMedian: Double)
14 | 
15 | val katanaTimings = mutableListOf<Timings>()
16 | val koinTimings = mutableListOf<Timings>()
17 | val kodeinTimings = mutableListOf<Timings>()
18 | 
19 | fun main(args: Array<String>) {
20 |     println("Running $ITERATIONS iterations. Please stand by...")
21 | 
22 |     repeat(ITERATIONS) {
23 |         val katana = KatanaSubject()
24 |         katanaTimings.add(measure(katana))
25 | 
26 |         val koin = KoinSubject()
27 |         koinTimings.add(measure(koin))
28 | 
29 |         val kodein = KodeinSubject()
30 |         kodeinTimings.add(measure(kodein))
31 |     }
32 | 
33 |     println()
34 | 
35 |     println("=== Katana ===")
36 |     katanaTimings.results().print()
37 |     println()
38 | 
39 |     println("=== Koin ===")
40 |     koinTimings.results().print()
41 |     println()
42 | 
43 |     println("=== Kodein ===")
44 |     kodeinTimings.results().print()
45 |     println()
46 | }
47 | 
48 | fun measure(subject: Subject): Timings {
49 |     val setup = measureCall { subject.setup() }
50 |     val execution = measureCall { subject.execute() }
51 |     subject.shutdown()
52 |     return Timings(setup, execution)
53 | }
54 | 
55 | fun measureCall(body: () -> Unit): Long {
56 |     val before = System.nanoTime()
57 |     body()
58 |     val after = System.nanoTime()
59 |     return after - before
60 | }
61 | 
62 | fun Iterable<Timings>.results() =
63 |     Results(setupAverage = map { it.setup }.average(),
64 |             setupMedian = map { it.setup }.median(),
65 |             executionAverage = map { it.execution }.average(),
66 |             executionMedian = map { it.execution }.median())
67 | 
68 | fun Results.print() {
69 |     println("setup (average):     $setupAverage ns")
70 |     println("setup (median):      $setupMedian ns")
71 |     println("execution (average): $executionAverage ns")
72 |     println("execution (median):  $executionMedian ns")
73 | }
74 | 
75 | fun Double.toMillis() = this / 1_000_000
76 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/view/FirstFragment.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment.view
 2 | 
 3 | import android.os.Bundle
 4 | import android.view.LayoutInflater
 5 | import android.view.View
 6 | import android.view.ViewGroup
 7 | import androidx.fragment.app.Fragment
 8 | import kotlinx.android.synthetic.main.fragment_first.view.*
 9 | import org.rewedigital.katana.Component
10 | import org.rewedigital.katana.KatanaTrait
11 | import org.rewedigital.katana.android.example.R
12 | import org.rewedigital.katana.android.example.fragment.FRAGMENT_DEPENDENCY1
13 | import org.rewedigital.katana.android.example.fragment.FirstFragmentModule
14 | import org.rewedigital.katana.android.example.fragment.SOME_DEPENDENCY
15 | import org.rewedigital.katana.android.fragment.KatanaFragmentDelegate
16 | import org.rewedigital.katana.android.fragment.fragmentDelegate
17 | import org.rewedigital.katana.injectNow
18 | 
19 | /**
20 |  * Showcasing usage of Katana in a Fragment which has a dependency relation to the parent Activity.
21 |  * Since the Activity is instantiated **after** the Fragment instance, we need to take special care
22 |  * of this situation.
23 |  *
24 |  * @see KatanaFragmentDelegate
25 |  * @see SecondFragment
26 |  */
27 | class FirstFragment(
28 |     superComponent: Component
29 | ) : Fragment(), KatanaTrait {
30 | 
31 |     private val fragmentDelegate: KatanaFragmentDelegate<FirstFragment>
32 | 
33 |     override lateinit var component: Component
34 |     private lateinit var activityDependency: String
35 |     private lateinit var fragmentDependency: String
36 | 
37 |     init {
38 |         fragmentDelegate = fragmentDelegate { _, _ ->
39 |             component = superComponent + FirstFragmentModule
40 | 
41 |             activityDependency = injectNow(SOME_DEPENDENCY)
42 |             fragmentDependency = injectNow(FRAGMENT_DEPENDENCY1)
43 | 
44 |             view?.textView?.text =
45 |                 context?.getString(R.string.first_fragment, activityDependency, fragmentDependency)
46 |         }
47 |     }
48 | 
49 |     override fun onCreateView(
50 |         inflater: LayoutInflater,
51 |         container: ViewGroup?,
52 |         savedInstanceState: Bundle?
53 |     ): View? =
54 |         inflater.inflate(R.layout.fragment_first, container, false)
55 | 
56 |     override fun onActivityCreated(savedInstanceState: Bundle?) {
57 |         super.onActivityCreated(savedInstanceState)
58 | 
59 |         fragmentDelegate.onActivityCreated(savedInstanceState)
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/android-example/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.application")
 3 |     kotlin("android")
 4 |     kotlin("android.extensions")
 5 | }
 6 | 
 7 | android {
 8 |     compileSdkVersion(Android.compileSdkVersion)
 9 | 
10 |     defaultConfig {
11 |         minSdkVersion(19)
12 |         targetSdkVersion(Android.targetSdkVersion)
13 |         buildToolsVersion(Android.buildToolsVersion)
14 | 
15 |         applicationId = "org.rewedigital.katana.android.example"
16 |         versionCode = 1
17 |         versionName = Version.version
18 | 
19 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
20 |     }
21 | 
22 |     sourceSets {
23 |         getByName("androidTest").java.srcDirs("src/androidTest/kotlin")
24 |         getByName("main").java.srcDirs("src/main/kotlin")
25 |         getByName("debug").java.srcDirs("src/debug/kotlin")
26 |         getByName("release").java.srcDirs("src/release/kotlin")
27 |         getByName("test").java.srcDirs("src/test/kotlin")
28 |     }
29 | 
30 |     lintOptions {
31 |         isAbortOnError = false
32 |     }
33 | 
34 |     compileOptions {
35 |         sourceCompatibility = JavaVersion.VERSION_1_8
36 |         targetCompatibility = JavaVersion.VERSION_1_8
37 |     }
38 | 
39 |     kotlinOptions {
40 |         jvmTarget = JavaVersion.VERSION_1_8.toString()
41 |     }
42 | }
43 | 
44 | dependencies {
45 |     implementation(project(":android"))
46 |     implementation(project(":androidx-fragment"))
47 |     implementation(project(":androidx-viewmodel-savedstate"))
48 |     implementation("androidx.appcompat:appcompat:1.2.0")
49 |     implementation("androidx.constraintlayout:constraintlayout:2.0.4")
50 |     implementation("org.jetbrains.kotlin:kotlin-reflect:1.5.0")
51 |     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3")
52 |     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3")
53 |     implementation("org.jetbrains.anko:anko-coroutines:0.10.8")
54 |     implementation("com.squareup.retrofit2:retrofit:2.9.0")
55 |     implementation("com.squareup.retrofit2:converter-moshi:2.9.0")
56 |     implementation("com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2")
57 |     implementation("com.squareup.moshi:moshi:1.12.0")
58 |     implementation("com.squareup.moshi:moshi-kotlin:1.12.0") {
59 |         exclude(group = "org.jetbrains.kotlin")
60 |     }
61 | 
62 |     debugImplementation("com.squareup.leakcanary:leakcanary-android:2.7")
63 | 
64 |     androidTestImplementation("androidx.test.espresso:espresso-core:3.3.0")
65 |     androidTestImplementation("androidx.test:runner:1.3.0")
66 |     androidTestImplementation("androidx.test:rules:1.3.0")
67 |     androidTestImplementation("androidx.test.ext:junit:1.1.2")
68 | }
69 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/NamedInjectionTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBeEqualTo
 4 | import org.rewedigital.katana.NamedInjectionTests.Key5
 5 | import org.rewedigital.katana.NamedInjectionTests.Key6
 6 | import org.rewedigital.katana.NamedInjectionTests.Key7
 7 | import org.rewedigital.katana.NamedInjectionTests.Key8
 8 | import org.rewedigital.katana.dsl.factory
 9 | import org.spekframework.spek2.Spek
10 | import org.spekframework.spek2.style.specification.describe
11 | 
12 | object NamedInjectionTests : Spek(
13 |     {
14 |         val module by memoized {
15 |             Module {
16 |                 factory(name = Key1) { "First" }
17 |                 factory(name = Key2) { "Second" }
18 | 
19 |                 factory(name = Keys.Key3) { "Third" }
20 |                 factory(name = Keys.Key4) { "Fourth" }
21 | 
22 |                 factory(name = Key5) { "Fifth" }
23 |                 factory(name = Key6) { "Sixth" }
24 | 
25 |                 factory(name = Key7) { "Seventh" }
26 |                 factory(name = Key8) { "Eighth" }
27 |             }
28 |         }
29 | 
30 |         val component by memoized { Component(module) }
31 | 
32 |         describe("Named injection") {
33 | 
34 |             context("with Kotlin objects") {
35 | 
36 |                 it("should work") {
37 |                     component.injectNow<String>(Key1) shouldBeEqualTo "First"
38 |                     component.injectNow<String>(Key2) shouldBeEqualTo "Second"
39 |                 }
40 |             }
41 | 
42 |             context("with enum class") {
43 | 
44 |                 it("should work") {
45 |                     component.injectNow<String>(Keys.Key3) shouldBeEqualTo "Third"
46 |                     component.injectNow<String>(Keys.Key4) shouldBeEqualTo "Fourth"
47 |                 }
48 |             }
49 | 
50 |             context("with Strings") {
51 | 
52 |                 it("should work") {
53 |                     component.injectNow<String>(Key5) shouldBeEqualTo "Fifth"
54 |                     component.injectNow<String>(Key6) shouldBeEqualTo "Sixth"
55 |                 }
56 |             }
57 | 
58 |             context("with custom data class") {
59 | 
60 |                 it("should work") {
61 |                     component.injectNow<String>(Key7) shouldBeEqualTo "Seventh"
62 |                     component.injectNow<String>(Key8) shouldBeEqualTo "Eighth"
63 |                 }
64 |             }
65 |         }
66 |     }) {
67 | 
68 |     object Key1
69 |     object Key2
70 | 
71 |     enum class Keys { Key3, Key4 }
72 | 
73 |     const val Key5 = "Key5"
74 |     const val Key6 = "Key6"
75 | 
76 |     data class CustomKey(val id: String)
77 | 
78 |     val Key7 = CustomKey("Key7")
79 |     val Key8 = CustomKey("Key8")
80 | }
81 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/fragment/view/SecondFragment.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.fragment.view
 2 | 
 3 | import android.app.Activity
 4 | import android.os.Bundle
 5 | import android.view.LayoutInflater
 6 | import android.view.View
 7 | import android.view.ViewGroup
 8 | import kotlinx.android.synthetic.main.fragment_second.view.*
 9 | import org.rewedigital.katana.Component
10 | import org.rewedigital.katana.KatanaTrait
11 | import org.rewedigital.katana.android.example.R
12 | import org.rewedigital.katana.android.example.fragment.SecondFragmentModule
13 | import org.rewedigital.katana.android.example.fragment.inject.Container
14 | import org.rewedigital.katana.android.example.fragment.model.SecondFragmentViewModel
15 | import org.rewedigital.katana.android.fragment.KatanaFragment
16 | import org.rewedigital.katana.androidx.viewmodel.savedstate.viewModelSavedStateNow
17 | import org.rewedigital.katana.injectNow
18 | 
19 | /**
20 |  * See [FirstFragment] first.
21 |  * This is an alternative approach to the Fragment/Activity relation issue.
22 |  *
23 |  * Also this fragment showcases Katana's support for [androidx.lifecycle.ViewModel].
24 |  *
25 |  * @see FirstFragment
26 |  * @see SecondFragmentModule
27 |  * @see KatanaFragment
28 |  */
29 | class SecondFragment(
30 |     private val superComponent: Component
31 | ) : KatanaFragment(), KatanaTrait {
32 | 
33 |     override lateinit var component: Component
34 |     private lateinit var container: Container
35 |     private lateinit var viewModel: SecondFragmentViewModel
36 | 
37 |     override fun onCreateView(
38 |         inflater: LayoutInflater,
39 |         container: ViewGroup?,
40 |         savedInstanceState: Bundle?
41 |     ): View? =
42 |         inflater.inflate(R.layout.fragment_second, container, false).apply {
43 |             button.setOnClickListener {
44 |                 viewModel.message = editText.text?.toString()
45 |                 updateMessage()
46 |             }
47 |         }
48 | 
49 |     override fun onInject(activity: Activity, savedInstanceState: Bundle?) {
50 |         component = superComponent + SecondFragmentModule
51 | 
52 |         container = injectNow()
53 |         viewModel = viewModelSavedStateNow()
54 | 
55 |         updateMessage()
56 |     }
57 | 
58 |     private fun updateMessage() {
59 |         val message = StringBuilder().apply {
60 |             append(
61 |                 context?.getString(
62 |                     R.string.second_fragment,
63 |                     container.activityDependency,
64 |                     container.fragmentDependency
65 |                 )
66 |             )
67 | 
68 |             append(" ${viewModel.message.orEmpty()}")
69 |         }.trim()
70 | 
71 |         view?.textView?.text = message
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/LoggerTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBeEqualTo
 4 | import org.amshove.kluent.shouldContain
 5 | import org.rewedigital.katana.internal.Logger
 6 | import org.spekframework.spek2.Spek
 7 | import org.spekframework.spek2.style.specification.describe
 8 | 
 9 | object LoggerTests : Spek(
10 |     {
11 | 
12 |         data class LogEntry(val msg: String, val throwable: Throwable? = null)
13 | 
14 |         class TestLogger : Katana.Logger {
15 | 
16 |             val debug = mutableListOf<LogEntry>()
17 |             val info = mutableListOf<LogEntry>()
18 |             val warn = mutableListOf<LogEntry>()
19 |             val error = mutableListOf<LogEntry>()
20 | 
21 |             override fun debug(msg: String) {
22 |                 debug.add(LogEntry(msg))
23 |             }
24 | 
25 |             override fun info(msg: String) {
26 |                 info.add(LogEntry(msg))
27 |             }
28 | 
29 |             override fun warn(msg: String) {
30 |                 warn.add(LogEntry(msg))
31 |             }
32 | 
33 |             override fun error(msg: String, throwable: Throwable?) {
34 |                 error.add(LogEntry(msg, throwable))
35 |             }
36 |         }
37 | 
38 |         describe("Logger") {
39 | 
40 |             it("should log when logger is set") {
41 |                 val logger = TestLogger()
42 |                 val exception = Exception("Exception")
43 | 
44 |                 Katana.logger = logger
45 | 
46 |                 Logger.debug { "Debug message" }
47 |                 Logger.info { "Info message" }
48 |                 Logger.warn { "Warn message" }
49 |                 Logger.error { Pair("Error message", exception) }
50 | 
51 |                 logger.debug shouldContain LogEntry("Debug message")
52 |                 logger.info shouldContain LogEntry("Info message")
53 |                 logger.warn shouldContain LogEntry("Warn message")
54 |                 logger.error shouldContain LogEntry("Error message", exception)
55 |             }
56 | 
57 |             it("should NOT log when logger is absent") {
58 |                 Katana.logger = null
59 | 
60 |                 var debugCalled = false
61 |                 var infoCalled = false
62 |                 var warnCalled = false
63 |                 var errorCalled = false
64 | 
65 |                 Logger.debug { debugCalled = true; "Debug message" }
66 |                 Logger.info { infoCalled = true; "Info message" }
67 |                 Logger.warn { warnCalled = true; "Warn message" }
68 |                 Logger.error { errorCalled = true; Pair("Error message", Exception()) }
69 | 
70 |                 debugCalled shouldBeEqualTo false
71 |                 infoCalled shouldBeEqualTo false
72 |                 warnCalled shouldBeEqualTo false
73 |                 errorCalled shouldBeEqualTo false
74 |             }
75 |         }
76 |     })
77 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @rem
 2 | @rem Copyright 2015 the original author or authors.
 3 | @rem
 4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
 5 | @rem you may not use this file except in compliance with the License.
 6 | @rem You may obtain a copy of the License at
 7 | @rem
 8 | @rem      https://www.apache.org/licenses/LICENSE-2.0
 9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 | 
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem  Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 | 
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 | 
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 | 
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 | 
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 | 
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 | 
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if "%ERRORLEVEL%" == "0" goto execute
44 | 
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 | 
51 | goto fail
52 | 
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 | 
57 | if exist "%JAVA_EXE%" goto execute
58 | 
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 | 
65 | goto fail
66 | 
67 | :execute
68 | @rem Setup the command line
69 | 
70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 | 
72 | 
73 | @rem Execute Gradle
74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
75 | 
76 | :end
77 | @rem End local scope for the variables with windows NT shell
78 | if "%ERRORLEVEL%"=="0" goto mainEnd
79 | 
80 | :fail
81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 | rem the _cmd.exe /c_ return code!
83 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
84 | exit /b 1
85 | 
86 | :mainEnd
87 | if "%OS%"=="Windows_NT" endlocal
88 | 
89 | :omega
90 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/ModuleIncludesTest.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldBeEqualTo
 4 | import org.rewedigital.katana.dsl.factory
 5 | import org.spekframework.spek2.Spek
 6 | import org.spekframework.spek2.style.specification.describe
 7 | 
 8 | object ModuleIncludesTest : Spek(
 9 |     {
10 |         val module1 by memoized {
11 |             Module {
12 |                 factory(name = "Module1") { "Module1" }
13 |             }
14 |         }
15 |         val module2 by memoized {
16 |             Module {
17 |                 factory(name = "Module2") { "Module2" }
18 |             }
19 |         }
20 |         val module3 by memoized {
21 |             Module(includes = listOf(module1, module2)) {
22 |                 factory(name = "Module3") { "Module3" }
23 |             }
24 |         }
25 |         val module4 by memoized {
26 |             Module(includes = listOf(module1, module3), declarations = {
27 |                 factory(name = "Module4") { "Module4" }
28 |             })
29 |         }
30 |         val module5 by memoized {
31 |             Module(includes = listOf(module1, module2))
32 |         }
33 | 
34 |         describe("Module includes") {
35 | 
36 |             it("should include referenced modules") {
37 |                 val component = Component(module3)
38 | 
39 |                 component.injectNow<String>("Module1") shouldBeEqualTo "Module1"
40 |                 component.injectNow<String>("Module2") shouldBeEqualTo "Module2"
41 |                 component.injectNow<String>("Module3") shouldBeEqualTo "Module3"
42 |             }
43 | 
44 |             it("should work when same modules are included multiple times") {
45 |                 val component = Component(module4)
46 | 
47 |                 component.injectNow<String>("Module1") shouldBeEqualTo "Module1"
48 |                 component.injectNow<String>("Module2") shouldBeEqualTo "Module2"
49 |                 component.injectNow<String>("Module3") shouldBeEqualTo "Module3"
50 |                 component.injectNow<String>("Module4") shouldBeEqualTo "Module4"
51 |             }
52 | 
53 |             it("should work when same modules are included multiple times via components") {
54 |                 val component1 = Component(module3)
55 |                 val component2 = Component(modules = listOf(module3), dependsOn = listOf(component1))
56 | 
57 |                 component2.injectNow<String>("Module1") shouldBeEqualTo "Module1"
58 |                 component2.injectNow<String>("Module2") shouldBeEqualTo "Module2"
59 |                 component2.injectNow<String>("Module3") shouldBeEqualTo "Module3"
60 |             }
61 | 
62 |             it("alias modules should be possible") {
63 |                 val component = Component(module5)
64 | 
65 |                 component.injectNow<String>("Module1") shouldBeEqualTo "Module1"
66 |                 component.injectNow<String>("Module2") shouldBeEqualTo "Module2"
67 |                 component.canInject<String>("Module3") shouldBeEqualTo false
68 |             }
69 |         }
70 |     })
71 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/OverrideTests.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana
 2 | 
 3 | import org.amshove.kluent.shouldNotThrow
 4 | import org.amshove.kluent.shouldThrow
 5 | import org.rewedigital.katana.dsl.factory
 6 | import org.rewedigital.katana.dsl.get
 7 | import org.spekframework.spek2.Spek
 8 | import org.spekframework.spek2.style.specification.describe
 9 | 
10 | object OverrideTests : Spek(
11 |     {
12 |         describe("Modules with overrides") {
13 | 
14 |             it("should throw exception when dependencies are overridden in same module") {
15 |                 val fn = {
16 |                     Module {
17 | 
18 |                         factory<MyComponent> { MyComponentA() }
19 | 
20 |                         factory<MyComponent> { MyComponentA() }
21 |                     }
22 |                 }
23 | 
24 |                 fn shouldThrow OverrideException::class
25 |             }
26 | 
27 |             it("should throw exception when dependencies are overridden in same module with identical names") {
28 |                 val fn = {
29 |                     Module {
30 | 
31 |                         factory("component") { MyComponentA() }
32 | 
33 |                         factory("component") {
34 |                             MyComponentB("Hello world")
35 |                         }
36 |                     }
37 |                 }
38 | 
39 |                 fn shouldThrow OverrideException::class
40 |             }
41 | 
42 |             it("should throw exception when dependencies are overridden in multiple modules") {
43 |                 val module1 = Module {
44 | 
45 |                     factory<MyComponent> { MyComponentA() }
46 |                 }
47 | 
48 |                 val module2 = Module {
49 | 
50 |                     factory<MyComponent> { MyComponentA() }
51 |                 }
52 | 
53 |                 val fn = { Component(module1, module2) }
54 | 
55 |                 fn shouldThrow OverrideException::class
56 |             }
57 | 
58 |             it("should throw exception for internal module binding overrides") {
59 |                 val fn = {
60 |                     Module {
61 | 
62 |                         factory("internal", internal = true) { "Hello world" }
63 | 
64 |                         factory("internal", internal = true) { "Hello world" }
65 |                     }
66 |                 }
67 | 
68 |                 fn shouldThrow OverrideException::class
69 |             }
70 | 
71 |             it("should not throw exception for internal module binding overrides across module boundaries") {
72 |                 val module1 = Module {
73 | 
74 |                     factory("internal", internal = true) { "Hello world" }
75 | 
76 |                     factory { MyComponentA() }
77 |                 }
78 | 
79 |                 val module2 = Module {
80 | 
81 |                     factory("internal", internal = true) { "Hello world 2" }
82 | 
83 |                     factory { MyComponentB<String>(get("internal")) }
84 |                 }
85 | 
86 |                 val fn = {
87 |                     Component(module1, module2)
88 |                 }
89 | 
90 |                 fn shouldNotThrow OverrideException::class
91 |             }
92 |         }
93 |     })
94 | 


--------------------------------------------------------------------------------
/android-example/src/main/kotlin/org/rewedigital/katana/android/example/main/view/MainActivity.kt:
--------------------------------------------------------------------------------
 1 | package org.rewedigital.katana.android.example.main.view
 2 | 
 3 | import android.os.Bundle
 4 | import android.view.View
 5 | import android.view.ViewGroup
 6 | import android.widget.Button
 7 | import android.widget.ProgressBar
 8 | import android.widget.TextView
 9 | import android.widget.Toast
10 | import androidx.appcompat.app.AlertDialog
11 | import androidx.appcompat.app.AppCompatActivity
12 | import kotlinx.android.synthetic.main.activity_main.*
13 | import org.rewedigital.katana.Component
14 | import org.rewedigital.katana.KatanaTrait
15 | import org.rewedigital.katana.android.example.KatanaApp
16 | import org.rewedigital.katana.android.example.R
17 | import org.rewedigital.katana.android.example.main.MainModule
18 | import org.rewedigital.katana.android.example.main.Modules
19 | import org.rewedigital.katana.android.example.main.presenter.MainPresenter
20 | import org.rewedigital.katana.android.modules.ActivityModule
21 | import org.rewedigital.katana.inject
22 | 
23 | class MainActivity : AppCompatActivity(),
24 |     KatanaTrait,
25 |     MainView {
26 | 
27 |     // Component is created and referenced only from this Activity
28 |     override val component = Component(
29 |         modules = listOf(ActivityModule(this), MainModule(this)) + Modules.modules,
30 |         dependsOn = listOf(KatanaApp.applicationComponent)
31 |     )
32 |     private val presenter: MainPresenter by inject()
33 | 
34 |     private var dialog: AlertDialog? = null
35 | 
36 |     override fun onCreate(savedInstanceState: Bundle?) {
37 |         super.onCreate(savedInstanceState)
38 | 
39 |         setContentView(R.layout.activity_main)
40 | 
41 |         remoteButton.setOnClickListener { presenter.onRemoteButtonClick() }
42 |         exitButton.setOnClickListener { presenter.onExitButtonClick() }
43 | 
44 |         presenter.onCreate()
45 |     }
46 | 
47 |     override fun onDestroy() {
48 |         presenter.onDestroy()
49 |         dialog?.dismiss()
50 |         super.onDestroy()
51 |     }
52 | 
53 |     override fun addButton(id: String, label: String) {
54 |         findViewById<ViewGroup>(R.id.rootView).let { root ->
55 |             val button = Button(this).apply {
56 |                 text = label
57 |                 setOnClickListener {
58 |                     presenter.onButtonClick(id)
59 |                 }
60 |             }
61 |             root.addView(button, 0)
62 |         }
63 |     }
64 | 
65 |     override fun showToast(message: String) {
66 |         Toast.makeText(this, message, Toast.LENGTH_LONG).show()
67 |     }
68 | 
69 |     override fun showDialog() {
70 |         dialog = AlertDialog.Builder(this)
71 |             .setView(R.layout.dialog_remote)
72 |             .setPositiveButton(android.R.string.ok) { _, _ -> presenter.onDialogOkClick() }
73 |             .setOnDismissListener { dialog = null }
74 |             .show()
75 |     }
76 | 
77 |     override fun setDialogResult(result: String) {
78 |         dialog?.let { dlg ->
79 |             dlg.findViewById<ProgressBar>(R.id.progressBar)?.visibility = View.GONE
80 |             dlg.findViewById<TextView>(R.id.textView)?.let { textView ->
81 |                 textView.text = result
82 |                 textView.visibility = View.VISIBLE
83 |             }
84 |         }
85 |     }
86 | 
87 |     override fun dismissDialog() {
88 |         dialog?.dismiss()
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Build Status](https://github.com/rewe-digital/katana/workflows/Build/badge.svg)](https://github.com/rewe-digital/katana/actions?query=workflow%3ABuild) [![Kotlin](https://img.shields.io/badge/Kotlin-1.5.0-brightgreen.svg)](https://kotlinlang.org) [![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Katana-brightgreen.svg?style=flat)](https://android-arsenal.com/details/1/7365)
 2 | 
 3 | ‼️ This project is not maintained anymore. For more information
 4 | read [this statement](https://github.com/rewe-digital/katana/issues/22). ‼️
 5 | 
 6 | # Katana
 7 | 
 8 | Katana is a lightweight, minimalistic dependency injection library (similar to the service locator pattern) for Kotlin
 9 | on the JVM, designed especially with Android in mind.
10 | 
11 | * Extremely lightweight footprint (only ~15kB in classes and ~130 methods after ProGuard), plain Kotlin, no third-party dependencies
12 | * It's [fast](./speed-comparison) (also see this [comparison](https://github.com/Sloy/android-dependency-injection-performance))
13 | * "Less is more", therefore:
14 |   * No global singleton state. Likelihood of memory leaks is greatly reduced unless **YOU** are doing something wrong ;P 
15 |   * No reflection (see [this](#a-word-on-type-erasure) regarding type erasure)
16 |   * No code generation (unless `inline` functions count)
17 |   * No dependency overrides possible (see [Overrides](./Getting%20Started.md#overrides))
18 | 
19 | ## Getting Started
20 | 
21 | Want to know more? Please read [Getting Started](./Getting%20Started.md).
22 | 
23 | ## Artifacts
24 | 
25 | Katana consists of a core library and several additional libraries that extend
26 | Katana's functionality. All artifact are published in group 
27 | `org.rewedigital.katana`. Here's a quick overview of all available artifacts:
28 | 
29 | | Artifact                                                                | Description                                                                                   |
30 | | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
31 | | katana-core                                                             | Provides core functionality. Suitable for plain Kotlin (JVM) and Android.                     |
32 | | [katana-android](./android)                                             | Android-specific extensions like modules for `Activity` and `Fragment`, `KatanaFragment` etc. |
33 | | [katana-androidx-fragment](./androidx-fragment)                         | Additional support for `androidx.fragment` providing a Katana-based `FragmentFactory`.        |
34 | | [katana-androidx-viewmodel](./androidx-viewmodel)                       | Enables dependency injection for AndroidX ViewModel.                                          |
35 | | [katana-androidx-viewmodel-savedstate](./androidx-viewmodel-savedstate) | Support for AndroidX ViewModel with SavedState.                                               |
36 | 
37 | ## License
38 | 
39 | The MIT license (MIT)
40 | 
41 | Copyright (c) 2018-2021 REWE Digital GmbH
42 | 
43 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
44 | documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
45 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
46 | persons to whom the Software is furnished to do so, subject to the following conditions:
47 | 
48 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
49 | Software.
50 | 
51 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
52 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
53 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
54 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
55 | 


--------------------------------------------------------------------------------
/androidx-fragment/src/main/kotlin/org/rewedigital/katana/androidx/fragment/KatanaFragmentFactory.kt:
--------------------------------------------------------------------------------
  1 | package org.rewedigital.katana.androidx.fragment
  2 | 
  3 | import androidx.collection.ArrayMap
  4 | import androidx.fragment.app.Fragment
  5 | import androidx.fragment.app.FragmentFactory
  6 | import org.rewedigital.katana.Component
  7 | import org.rewedigital.katana.KatanaException
  8 | 
  9 | /**
 10 |  * A [FragmentFactory] that utilizes Katana for [Fragment] instance resolution.
 11 |  *
 12 |  * The factory can only provide instances of Fragments that have been registered via [handlesFragment] or
 13 |  * [handlesFragmentVia]. The referred component(s) must provide bindings for these Fragments.
 14 |  *
 15 |  * ```
 16 |  * val module = Module {
 17 |  *
 18 |  *   singleton {
 19 |  *       KatanaFragmentFactory(component)
 20 |  *           .handlesFragment<FirstFragment>()
 21 |  *           .handlesFragment<SecondFragment>(name = "SecondFragment")
 22 |  *   }
 23 |  *
 24 |  *   factory { FirstFragment(get()) }
 25 |  *
 26 |  *   factory(name = "SecondFragment") { SecondFragment(get(), get()) }
 27 |  * }
 28 |  * ```
 29 |  *
 30 |  * @param defaultComponent Optional default [Component] required for [handlesFragment]
 31 |  * @param delegateToSuper If `true`, will delegate requests to super FragmentFactory if this factory cannot resolve Fragment. Might be useful for third-party Fragments like `NavHostFragment` for instance.
 32 |  *
 33 |  * @see handlesFragment
 34 |  * @see handlesFragmentVia
 35 |  */
 36 | @Suppress("unused", "MemberVisibilityCanBePrivate")
 37 | class KatanaFragmentFactory(
 38 |     defaultComponent: Component? = null,
 39 |     private val delegateToSuper: Boolean = true
 40 | ) : FragmentFactory() {
 41 | 
 42 |     @PublishedApi
 43 |     internal val defaultComponentProvider =
 44 |         defaultComponent?.let { { it } }
 45 | 
 46 |     @PublishedApi
 47 |     internal val providers = ArrayMap<String, () -> Fragment>()
 48 | 
 49 |     /**
 50 |      * Declare that this factory handles Fragment instantiations of given type.
 51 |      *
 52 |      * A default [Component] **must** be passed to constructor of factory in order for this to work.
 53 |      * The default component must provide a binding for the requested Fragment which is bound to the class or
 54 |      * optional name. For instance a module might declare:
 55 |      *
 56 |      * ```
 57 |      * factory { MyFragment(get(), get()) }
 58 |      * ```
 59 |      *
 60 |      * Use [handlesFragmentVia] for adding a Fragment provider associated with a different component.
 61 |      *
 62 |      * @see handlesFragmentVia
 63 |      */
 64 |     inline fun <reified T : Fragment> handlesFragment(
 65 |         name: String? = null
 66 |     ): KatanaFragmentFactory {
 67 |         defaultComponentProvider?.let { component ->
 68 |             val fragmentClassName = T::class.java.name
 69 |             providers[fragmentClassName] = { component().injectNow<T>(name = name) }
 70 |         } ?: throw KatanaException("No default component passed to constructor of KatanaFragmentFactory")
 71 |         return this
 72 |     }
 73 | 
 74 |     /**
 75 |      * Declare that this factory handles Fragment instantiations via provided [Component].
 76 |      *
 77 |      * The supplied [Component] must provide a binding for the requested Fragment which is bound to the class or
 78 |      * optional name. For instance a module might declare:
 79 |      *
 80 |      * ```
 81 |      * factory { MyFragment(get(), get()) }
 82 |      * ```
 83 |      *
 84 |      * @see handlesFragment
 85 |      */
 86 |     inline fun <reified T : Fragment> handlesFragmentVia(
 87 |         name: String? = null,
 88 |         noinline component: () -> Component
 89 |     ): KatanaFragmentFactory {
 90 |         val fragmentClassName = T::class.java.name
 91 |         providers[fragmentClassName] = { component().injectNow<T>(name = name) }
 92 |         return this
 93 |     }
 94 | 
 95 |     /**
 96 |      * Create a new instance of a Fragment with the given class name.
 97 |      *
 98 |      * If this Fragment has not been registered via [handlesFragment] or [handlesFragmentVia] and [delegateToSuper] is `true`,
 99 |      * will call super [FragmentFactory] for resolution. Else throws [KatanaException].
100 |      *
101 |      * @throws KatanaException
102 |      */
103 |     override fun instantiate(classLoader: ClassLoader, className: String) =
104 |         providers[className]?.let { provider ->
105 |             provider()
106 |         } ?: if (delegateToSuper)
107 |             super.instantiate(
108 |                 classLoader,
109 |                 className
110 |             ) else throw KatanaException("No Fragment provider found for class $className (delegateToSuper == false)")
111 | }
112 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | #
  4 | # Copyright 2015 the original author or authors.
  5 | #
  6 | # Licensed under the Apache License, Version 2.0 (the "License");
  7 | # you may not use this file except in compliance with the License.
  8 | # You may obtain a copy of the License at
  9 | #
 10 | #      https://www.apache.org/licenses/LICENSE-2.0
 11 | #
 12 | # Unless required by applicable law or agreed to in writing, software
 13 | # distributed under the License is distributed on an "AS IS" BASIS,
 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | # See the License for the specific language governing permissions and
 16 | # limitations under the License.
 17 | #
 18 | 
 19 | ##############################################################################
 20 | ##
 21 | ##  Gradle start up script for UN*X
 22 | ##
 23 | ##############################################################################
 24 | 
 25 | # Attempt to set APP_HOME
 26 | # Resolve links: $0 may be a link
 27 | PRG="$0"
 28 | # Need this for relative symlinks.
 29 | while [ -h "$PRG" ] ; do
 30 |     ls=`ls -ld "$PRG"`
 31 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 32 |     if expr "$link" : '/.*' > /dev/null; then
 33 |         PRG="$link"
 34 |     else
 35 |         PRG=`dirname "$PRG"`"/$link"
 36 |     fi
 37 | done
 38 | SAVED="`pwd`"
 39 | cd "`dirname \"$PRG\"`/" >/dev/null
 40 | APP_HOME="`pwd -P`"
 41 | cd "$SAVED" >/dev/null
 42 | 
 43 | APP_NAME="Gradle"
 44 | APP_BASE_NAME=`basename "$0"`
 45 | 
 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 48 | 
 49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 50 | MAX_FD="maximum"
 51 | 
 52 | warn () {
 53 |     echo "$*"
 54 | }
 55 | 
 56 | die () {
 57 |     echo
 58 |     echo "$*"
 59 |     echo
 60 |     exit 1
 61 | }
 62 | 
 63 | # OS specific support (must be 'true' or 'false').
 64 | cygwin=false
 65 | msys=false
 66 | darwin=false
 67 | nonstop=false
 68 | case "`uname`" in
 69 |   CYGWIN* )
 70 |     cygwin=true
 71 |     ;;
 72 |   Darwin* )
 73 |     darwin=true
 74 |     ;;
 75 |   MINGW* )
 76 |     msys=true
 77 |     ;;
 78 |   NONSTOP* )
 79 |     nonstop=true
 80 |     ;;
 81 | esac
 82 | 
 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 84 | 
 85 | 
 86 | # Determine the Java command to use to start the JVM.
 87 | if [ -n "$JAVA_HOME" ] ; then
 88 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 89 |         # IBM's JDK on AIX uses strange locations for the executables
 90 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 91 |     else
 92 |         JAVACMD="$JAVA_HOME/bin/java"
 93 |     fi
 94 |     if [ ! -x "$JAVACMD" ] ; then
 95 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 96 | 
 97 | Please set the JAVA_HOME variable in your environment to match the
 98 | location of your Java installation."
 99 |     fi
100 | else
101 |     JAVACMD="java"
102 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
103 | 
104 | Please set the JAVA_HOME variable in your environment to match the
105 | location of your Java installation."
106 | fi
107 | 
108 | # Increase the maximum file descriptors if we can.
109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
110 |     MAX_FD_LIMIT=`ulimit -H -n`
111 |     if [ $? -eq 0 ] ; then
112 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
113 |             MAX_FD="$MAX_FD_LIMIT"
114 |         fi
115 |         ulimit -n $MAX_FD
116 |         if [ $? -ne 0 ] ; then
117 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
118 |         fi
119 |     else
120 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
121 |     fi
122 | fi
123 | 
124 | # For Darwin, add options to specify how the application appears in the dock
125 | if $darwin; then
126 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
127 | fi
128 | 
129 | # For Cygwin or MSYS, switch paths to Windows format before running java
130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
131 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
132 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
133 | 
134 |     JAVACMD=`cygpath --unix "$JAVACMD"`
135 | 
136 |     # We build the pattern for arguments to be converted via cygpath
137 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
138 |     SEP=""
139 |     for dir in $ROOTDIRSRAW ; do
140 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
141 |         SEP="|"
142 |     done
143 |     OURCYGPATTERN="(^($ROOTDIRS))"
144 |     # Add a user-defined pattern to the cygpath arguments
145 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
146 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
147 |     fi
148 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
149 |     i=0
150 |     for arg in "$@" ; do
151 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
152 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
153 | 
154 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
155 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
156 |         else
157 |             eval `echo args$i`="\"$arg\""
158 |         fi
159 |         i=`expr $i + 1`
160 |     done
161 |     case $i in
162 |         0) set -- ;;
163 |         1) set -- "$args0" ;;
164 |         2) set -- "$args0" "$args1" ;;
165 |         3) set -- "$args0" "$args1" "$args2" ;;
166 |         4) set -- "$args0" "$args1" "$args2" "$args3" ;;
167 |         5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
168 |         6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
169 |         7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
170 |         8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
171 |         9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
172 |     esac
173 | fi
174 | 
175 | # Escape application args
176 | save () {
177 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
178 |     echo " "
179 | }
180 | APP_ARGS=`save "$@"`
181 | 
182 | # Collect all arguments for the java command, following the shell quoting and substitution rules
183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
184 | 
185 | exec "$JAVACMD" "$@"
186 | 


--------------------------------------------------------------------------------
/androidx-viewmodel/src/main/kotlin/org/rewedigital/katana/androidx/viewmodel/ViewModel.kt:
--------------------------------------------------------------------------------
  1 | @file:Suppress("unused")
  2 | 
  3 | package org.rewedigital.katana.androidx.viewmodel
  4 | 
  5 | import androidx.fragment.app.Fragment
  6 | import androidx.fragment.app.FragmentActivity
  7 | import androidx.lifecycle.ViewModel
  8 | import androidx.lifecycle.ViewModelProvider
  9 | import androidx.lifecycle.ViewModelStoreOwner
 10 | import org.rewedigital.katana.Component
 11 | import org.rewedigital.katana.KatanaTrait
 12 | import org.rewedigital.katana.ModuleBindingContext
 13 | import org.rewedigital.katana.androidx.viewmodel.internal.viewModelName
 14 | import org.rewedigital.katana.dsl.ProviderDsl
 15 | import org.rewedigital.katana.dsl.factory
 16 | 
 17 | //<editor-fold desc="Internal utility functions and classes">
 18 | @Suppress("UNCHECKED_CAST")
 19 | @PublishedApi
 20 | internal class KatanaViewModelProviderFactory(private val viewModelProvider: () -> ViewModel) :
 21 |     ViewModelProvider.Factory {
 22 | 
 23 |     override fun <VM : ViewModel> create(modelClass: Class<VM>) =
 24 |         viewModelProvider() as VM
 25 | }
 26 | 
 27 | @PublishedApi
 28 | internal inline fun <reified VM : ViewModel> ViewModelProvider.get(key: String?) =
 29 |     when (key) {
 30 |         null -> get(VM::class.java)
 31 |         else -> get(key, VM::class.java)
 32 |     }
 33 | 
 34 | @PublishedApi
 35 | internal object InternalViewModelProvider {
 36 | 
 37 |     inline fun <reified VM : ViewModel> of(
 38 |         owner: ViewModelStoreOwner,
 39 |         key: String?,
 40 |         noinline viewModelProvider: () -> ViewModel
 41 |     ) =
 42 |         ViewModelProvider(
 43 |             owner,
 44 |             KatanaViewModelProviderFactory(viewModelProvider)
 45 |         ).get<VM>(key)
 46 | }
 47 | //</editor-fold>
 48 | 
 49 | //<editor-fold desc="Module DSL">
 50 | /**
 51 |  * Declares a [ViewModel] dependency binding.
 52 |  *
 53 |  * Body of provider syntax facilitates arbitrary dependency injection into the ViewModel when first instantiated.
 54 |  * **Important:** The ViewModel instance is handled by AndroidX's [ViewModelProvider] and not by Katana itself.
 55 |  *
 56 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
 57 |  *
 58 |  * @see ProviderDsl.viewModel
 59 |  * @see ProviderDsl.activityViewModel
 60 |  */
 61 | inline fun <reified VM : ViewModel> ModuleBindingContext.viewModel(
 62 |     key: String? = null,
 63 |     noinline body: ProviderDsl.() -> VM
 64 | ) =
 65 |     factory(name = viewModelName(modelClass = VM::class.java, key = key), body = body)
 66 | 
 67 | /**
 68 |  * Provides [ViewModel] instance of given [ViewModelStoreOwner] declared in current injection context.
 69 |  */
 70 | inline fun <reified VM : ViewModel> ProviderDsl.viewModel(owner: ViewModelStoreOwner, key: String? = null) =
 71 |     InternalViewModelProvider.of<VM>(owner, key) {
 72 |         context.injectNow(name = viewModelName(VM::class.java, key))
 73 |     }
 74 | 
 75 | /**
 76 |  * Provides [Fragment] [ViewModel] instance scoped to its [FragmentActivity] declared in current injection context.
 77 |  */
 78 | inline fun <reified VM : ViewModel> ProviderDsl.activityViewModel(fragment: Fragment, key: String? = null) =
 79 |     viewModel<VM>(owner = fragment.requireActivity(), key = key)
 80 | //</editor-fold>
 81 | 
 82 | //<editor-fold desc="Injection extension functions">
 83 | /**
 84 |  * Immediately injects [ViewModel] of specified [ViewModelStoreOwner].
 85 |  *
 86 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
 87 |  *
 88 |  * @see ModuleBindingContext.viewModel
 89 |  */
 90 | inline fun <reified VM : ViewModel> Component.viewModelNow(owner: ViewModelStoreOwner, key: String? = null) =
 91 |     InternalViewModelProvider.of<VM>(owner, key) {
 92 |         injectNow(name = viewModelName(VM::class.java, key))
 93 |     }
 94 | 
 95 | @PublishedApi
 96 | internal inline fun <reified VM : ViewModel> Component.internalViewModel(
 97 |     noinline ownerProvider: () -> ViewModelStoreOwner,
 98 |     key: String? = null
 99 | ) =
100 |     lazy { viewModelNow<VM>(ownerProvider(), key) }
101 | 
102 | /**
103 |  * Injects [ViewModel] of specified [ViewModelStoreOwner].
104 |  *
105 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
106 |  *
107 |  * @see ModuleBindingContext.viewModel
108 |  */
109 | inline fun <reified VM : ViewModel> Component.viewModel(owner: ViewModelStoreOwner, key: String? = null) =
110 |     internalViewModel<VM>(ownerProvider = { owner }, key = key)
111 | 
112 | /**
113 |  * Immediately injects [ViewModel] of current [ViewModelStoreOwner] implementing [KatanaTrait] interface.
114 |  *
115 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
116 |  *
117 |  * @see ModuleBindingContext.viewModel
118 |  */
119 | inline fun <reified VM : ViewModel, T> T.viewModelNow(key: String? = null) where T : KatanaTrait, T : ViewModelStoreOwner =
120 |     component.viewModelNow<VM>(this, key)
121 | 
122 | /**
123 |  * Injects [ViewModel] of current [ViewModelStoreOwner] implementing [KatanaTrait] interface.
124 |  *
125 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
126 |  *
127 |  * @see ModuleBindingContext.viewModel
128 |  */
129 | inline fun <reified VM : ViewModel, T> T.viewModel(key: String? = null) where T : KatanaTrait, T : ViewModelStoreOwner =
130 |     component.viewModel<VM>(this, key)
131 | 
132 | /**
133 |  * Immediately injects [ViewModel] of specified [Fragment] scoped to its [FragmentActivity].
134 |  *
135 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
136 |  *
137 |  * @see ModuleBindingContext.viewModel
138 |  */
139 | inline fun <reified VM : ViewModel> Component.activityViewModelNow(fragment: Fragment, key: String? = null) =
140 |     viewModelNow<VM>(owner = fragment.requireActivity(), key = key)
141 | 
142 | /**
143 |  * Injects [ViewModel] of specified [Fragment] scoped to its [FragmentActivity].
144 |  *
145 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
146 |  *
147 |  * @see ModuleBindingContext.viewModel
148 |  */
149 | inline fun <reified VM : ViewModel> Component.activityViewModel(fragment: Fragment, key: String? = null) =
150 |     internalViewModel<VM>(ownerProvider = { fragment.requireActivity() }, key = key)
151 | 
152 | /**
153 |  * Immediately injects [ViewModel] of current [Fragment] implementing [KatanaTrait] scoped to its [FragmentActivity].
154 |  *
155 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
156 |  *
157 |  * @see ModuleBindingContext.viewModel
158 |  */
159 | inline fun <reified VM : ViewModel, T> T.activityViewModelNow(key: String? = null) where T : KatanaTrait, T : Fragment =
160 |     component.viewModelNow<VM>(owner = requireActivity(), key = key)
161 | 
162 | /**
163 |  * Injects [ViewModel] of current [Fragment] implementing [KatanaTrait] scoped to its [FragmentActivity].
164 |  *
165 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
166 |  *
167 |  * @see ModuleBindingContext.viewModel
168 |  */
169 | inline fun <reified VM : ViewModel, T> T.activityViewModel(key: String? = null) where T : KatanaTrait, T : Fragment =
170 |     component.internalViewModel<VM>(ownerProvider = { requireActivity() }, key = key)
171 | //</editor-fold>
172 | 


--------------------------------------------------------------------------------
/android-example/etc/launcher_icon.svg:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  2 | <!-- Created with Inkscape (http://www.inkscape.org/) -->
  3 | 
  4 | <svg
  5 |         xmlns:dc="http://purl.org/dc/elements/1.1/"
  6 |         xmlns:cc="http://creativecommons.org/ns#"
  7 |         xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  8 |         xmlns="http://www.w3.org/2000/svg"
  9 |         xmlns:xlink="http://www.w3.org/1999/xlink"
 10 |         xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
 11 |         xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
 12 |         width="108"
 13 |         height="108"
 14 |         viewBox="0 0 28.574999 28.575001"
 15 |         version="1.1"
 16 |         id="svg8"
 17 |         inkscape:version="0.92.4 (5da689c313, 2019-01-14)"
 18 |         sodipodi:docname="launcher_icon.svg">
 19 |     <defs
 20 |             id="defs2">
 21 |         <linearGradient
 22 |                 inkscape:collect="always"
 23 |                 id="linearGradient874">
 24 |             <stop
 25 |                     style="stop-color:#ff4242;stop-opacity:1"
 26 |                     offset="0"
 27 |                     id="stop870"/>
 28 |             <stop
 29 |                     style="stop-color:#ff0d0d;stop-opacity:1"
 30 |                     offset="1"
 31 |                     id="stop872"/>
 32 |         </linearGradient>
 33 |         <linearGradient
 34 |                 inkscape:collect="always"
 35 |                 xlink:href="#linearGradient874"
 36 |                 id="linearGradient876"
 37 |                 x1="4.7624998"
 38 |                 y1="4.7624998"
 39 |                 x2="23.8125"
 40 |                 y2="23.8125"
 41 |                 gradientUnits="userSpaceOnUse"/>
 42 |     </defs>
 43 |     <sodipodi:namedview
 44 |             id="base"
 45 |             pagecolor="#ffffff"
 46 |             bordercolor="#666666"
 47 |             borderopacity="1.0"
 48 |             inkscape:pageopacity="0.0"
 49 |             inkscape:pageshadow="2"
 50 |             inkscape:zoom="3"
 51 |             inkscape:cx="80"
 52 |             inkscape:cy="44.156863"
 53 |             inkscape:document-units="px"
 54 |             inkscape:current-layer="layer1"
 55 |             showgrid="false"
 56 |             units="px"
 57 |             showguides="true"
 58 |             inkscape:guide-bbox="true"
 59 |             inkscape:window-width="1920"
 60 |             inkscape:window-height="1027"
 61 |             inkscape:window-x="-8"
 62 |             inkscape:window-y="-8"
 63 |             inkscape:window-maximized="1"
 64 |             inkscape:pagecheckerboard="true">
 65 |         <sodipodi:guide
 66 |                 position="4.7625,4.7625"
 67 |                 orientation="0,1"
 68 |                 id="guide10"
 69 |                 inkscape:locked="false"
 70 |                 inkscape:label=""
 71 |                 inkscape:color="rgb(0,0,255)"/>
 72 |         <sodipodi:guide
 73 |                 position="23.8125,23.8125"
 74 |                 orientation="0,1"
 75 |                 id="guide12"
 76 |                 inkscape:locked="false"
 77 |                 inkscape:label=""
 78 |                 inkscape:color="rgb(0,0,255)"/>
 79 |         <sodipodi:guide
 80 |                 position="4.7625,23.8125"
 81 |                 orientation="1,0"
 82 |                 id="guide14"
 83 |                 inkscape:locked="false"
 84 |                 inkscape:label=""
 85 |                 inkscape:color="rgb(0,0,255)"/>
 86 |         <sodipodi:guide
 87 |                 position="23.8125,4.7625"
 88 |                 orientation="1,0"
 89 |                 id="guide22"
 90 |                 inkscape:locked="false"
 91 |                 inkscape:label=""
 92 |                 inkscape:color="rgb(0,0,255)"/>
 93 |         <sodipodi:guide
 94 |                 position="0,0"
 95 |                 orientation="0,1"
 96 |                 id="guide4563"
 97 |                 inkscape:locked="false"
 98 |                 inkscape:label=""
 99 |                 inkscape:color="rgb(0,0,255)"/>
100 |         <sodipodi:guide
101 |                 position="28.575,0"
102 |                 orientation="1,0"
103 |                 id="guide4565"
104 |                 inkscape:locked="false"
105 |                 inkscape:label=""
106 |                 inkscape:color="rgb(0,0,255)"/>
107 |         <inkscape:grid
108 |                 type="xygrid"
109 |                 id="grid4585"/>
110 |     </sodipodi:namedview>
111 |     <metadata
112 |             id="metadata5">
113 |         <rdf:RDF>
114 |             <cc:Work
115 |                     rdf:about="">
116 |                 <dc:format>image/svg+xml</dc:format>
117 |                 <dc:type
118 |                         rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
119 |                 <dc:title></dc:title>
120 |             </cc:Work>
121 |         </rdf:RDF>
122 |     </metadata>
123 |     <g
124 |             inkscape:groupmode="layer"
125 |             id="layer2"
126 |             inkscape:label="Hintergrund"
127 |             style="display:inline">
128 |         <rect
129 |                 style="fill:url(#linearGradient876);fill-opacity:1;stroke-width:0.29316965"
130 |                 id="rect4558"
131 |                 width="28.575001"
132 |                 height="28.575001"
133 |                 x="0"
134 |                 y="4.7683756e-08"/>
135 |     </g>
136 |     <g
137 |             inkscape:groupmode="layer"
138 |             id="layer3"
139 |             inkscape:label="Schattenwurf"
140 |             style="display:inline">
141 |         <path
142 |                 style="fill:#000000;fill-opacity:0.15686275;stroke:none;stroke-width:0.99999994px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
143 |                 d="M 72.296875,54.642578 56.816406,70.125 78.683594,108 H 108 V 90 75.255859 Z"
144 |                 transform="scale(0.26458333)"
145 |                 id="path853"
146 |                 inkscape:connector-curvature="0"/>
147 |     </g>
148 |     <g
149 |             inkscape:label="Vordergrund"
150 |             inkscape:groupmode="layer"
151 |             id="layer1"
152 |             transform="translate(0,-268.42498)"
153 |             style="display:inline">
154 |         <path
155 |                 style="clip-rule:evenodd;fill:#ffffff;fill-rule:evenodd;stroke-width:1.79166663"
156 |                 d="M 34.291016 34.291016 L 44.308594 44.603516 C 43.06697 46.241109 41.684857 48.815803 41.699219 50.759766 L 55.376953 64.435547 C 55.953868 65.014268 55.953868 65.952567 55.376953 66.53125 L 54.296875 67.607422 L 56.816406 70.125 L 72.296875 54.642578 L 69.779297 52.125 L 68.703125 53.201172 C 68.124419 53.779855 67.18792 53.779855 66.607422 53.201172 L 52.933594 39.527344 C 50.989635 39.512982 48.500864 40.885164 46.863281 42.125 L 38.916016 34.291016 L 34.291016 34.291016 z M 35.580078 38.871094 C 33.705995 41.666092 32.5 43.414938 32.5 45.115234 C 32.5 46.81553 33.877995 48.193359 35.580078 48.193359 C 37.28037 48.193359 38.65625 46.81553 38.65625 45.115234 C 38.65625 43.414938 37.454161 41.666092 35.580078 38.871094 z M 67.462891 62.015625 L 63.871094 65.607422 L 66.679688 68.417969 C 67.256606 68.994914 67.258397 69.931044 66.679688 70.509766 L 65.388672 71.800781 L 67.234375 73.708984 L 75.5 65.378906 L 73.65625 63.535156 L 72.365234 64.826172 C 71.788316 65.403079 70.848399 65.403079 70.271484 64.826172 L 67.462891 62.015625 z "
157 |                 transform="matrix(0.26458333,0,0,0.26458333,0,268.42498)"
158 |                 id="path840"/>
159 |     </g>
160 | </svg>
161 | 


--------------------------------------------------------------------------------
/Getting Started.md:
--------------------------------------------------------------------------------
  1 | # Getting Started
  2 | 
  3 | Katana consists of two core concepts: modules and components.
  4 | 
  5 | ## Module
  6 | 
  7 | A module describes **how** dependencies are provided. Each module should represent a logical unit. For instance there
  8 | might be a module for every feature of your application.
  9 | 
 10 | ```kotlin
 11 | val myModule = Module {
 12 | 
 13 |   // A "factory" declaration means that this dependency is instantiated every time when it's requested
 14 |   factory { MyDependency() }
 15 |   
 16 |   // A "singleton" declaration means that this dependency is only instantiated once (per component) 
 17 |   singleton { AnotherDependency() }
 18 |   
 19 |   // See how transitive dependencies can be injected with get() within the module's scope
 20 |   factory { YetAnotherDependency(get<MyDependency>(), get<AnotherDependency>()) }
 21 |   
 22 |   // Use named bindings when the type is not unique (there might be more Strings)
 23 |   singleton(name = "globalId") { "SOME_GLOBAL_ID" }
 24 |   
 25 |   // Use "eagerSingleton" for singleton instances which are instantiated as soon as the component
 26 |   // is created and not lazily the first time it's requested
 27 |   eagerSingleton { SomeEagerDependency() }
 28 |   
 29 |   // Declares a set-based multi-binding where every declaration inside set { } contribute to the set.
 30 |   // Set declarations may be segmented across multiple modules and components. 
 31 |   set<String> {
 32 |     factory { "Hello" }
 33 |     singleton { "World" }
 34 |   }
 35 | }
 36 | ```
 37 | 
 38 | ## Component
 39 | 
 40 | A component is composed of one or more modules. It performs the actual injection and is also responsible for holding
 41 | instances of dependencies which have been declared as singletons. This concept is important to understand! As long as
 42 | the same component reference is used, the same singleton instances will be provided by this component. The developer
 43 | is responsible for holding component references and releasing them when necessary. Only when the component is eligible
 44 | for garbage collection will its singletons be GC'd, too. This applies for module instances which were passed to a 
 45 | component, too. Module instances should only be held by a component and not stored anywhere else. Especially when the
 46 | module provides object instances outside of its own scope which were passed to the module during creation.
 47 | 
 48 | The component pattern has been introduced so that – especially in an Android environment – it is possible to inject
 49 | objects that should be released when the view has been destroyed, like for example the current `Context`.
 50 | 
 51 | ```kotlin
 52 | val component = Component(modules = listOf(myModuleA, myModuleB))
 53 | 
 54 | val myDependency: MyDependency by component.inject()
 55 | ```
 56 | 
 57 | By default injection is performed lazily with the `inject()` delegate. Dependencies can also be injected immediately 
 58 | with `injectNow()`. Latter should rarely be used!
 59 | 
 60 | Components can depend on other components. In this case the current component combines its own dependency declarations
 61 | with those from the parent components. Parent components should always have a scope (lifetime) which is equal or greater
 62 | than the current component or else memory leaks could be introduced. Imagine a component `A` and a component `B`. 
 63 | Component `A` declares `B` as a dependent component. `B` should be released but if `A` has a greater scope and is still
 64 | referenced somewhere `B` will remain in memory.
 65 | 
 66 | ```kotlin
 67 | val component = Component(
 68 |   modules = listOf(myModule),
 69 |   dependsOn = listOf(parentComponentA, parentComponentB)
 70 | )
 71 | ```
 72 | 
 73 | ## A word on type erasure
 74 | 
 75 | Katana doesn't use reflection. Therefor it cannot circumvent Java's [type erasure](https://docs.oracle.com/javase/tutorial/java/generics/erasure.html).
 76 | During runtime Katana will not be able to distinguish between `MyProvider<Int>` and `MyProvider<String>` when both 
 77 | dependencies are declared. The following code will result in an `OverrideException`:
 78 | 
 79 | ```kotlin
 80 | Module {
 81 |     
 82 |     factory { MyProvider<Int>(1337) }
 83 |     
 84 |     factory { MyProvider<String>("Hello world") }
 85 |     
 86 |     factory { MyDependency(get(), get()) }
 87 | }
 88 | ```
 89 | 
 90 | Luckily Katana provides a solution for this! Just use named injection :)
 91 | 
 92 | ```kotlin
 93 | enum class Names { IntProvider, StringProvider }
 94 | 
 95 | Module {
 96 |     
 97 |     factory(name = Names.IntProvider) { MyProvider<Int>(1337) }
 98 |     
 99 |     factory(name = Names.StringProvider) { MyProvider<String>("Hello world") }
100 |     
101 |     factory { MyDependency(get(Names.IntProvider), get(Names.StringProvider)) }
102 | }
103 | ```
104 | 
105 | ## Overrides 
106 | 
107 | Redeclarations of dependencies within modules, which would override existing declarations, are by design not possible 
108 | in Katana. We believe that overrides, especially when they happen silently, are a source of subtle bugs. If you require
109 | an override for example in a test scope, you should instead structure your modules in a way that overrides are not
110 | necessary. For example:
111 | 
112 | ```kotlin
113 | val commonModule = Module {
114 |     
115 |     singleton { MyCommonDependency() }
116 | }
117 | 
118 | val engineModule = Module {
119 |     
120 |     factory<MyEngine> { MyEngineImpl(get<MyCommonDependency>()) }
121 | }
122 | 
123 | val testEngineModule = Module {
124 |     
125 |     factory<MyEngine> { MyTestEngine(get<MyCommonDependency>()) }
126 | }
127 | 
128 | val productionComponent = Component(commonModule, engineModule)
129 | val testComponent = Component(commonModule, testEngineModule)
130 | ```
131 | 
132 | ## Circular dependencies
133 | 
134 | You should avoid circular dependencies. Let's imagine the following setup:
135 | 
136 | ```kotlin
137 | class A(b: B)
138 | 
139 | class B(a: A)
140 | 
141 | val module = Module {
142 | 
143 |     singleton { A(get()) }
144 | 
145 |     singleton { B(get()) }
146 | }
147 | 
148 | val component = Component(module)
149 | 
150 | val a: A by component.inject()
151 | ```
152 | 
153 | This will result in an `StackOverflowError` once Katana tries to provide an instance of `A`. When Katana executes the
154 | provider function of `A` it will try to solve the transitive dependency `B` which is required for `A`'s constructor.
155 | `B` however requires an instance of `A` and such an endless cycle is born.
156 | 
157 | The solution to this problem is to structure the classes in a way that a circular dependency is not necessary.
158 | For instance by creating a third class `C` which holds the functionality which both `A` and `B` require.
159 | 
160 | If there's no easy fix to this problem provide one dependency as `Lazy` as follows. 
161 | 
162 | ```kotlin
163 | class A2(b2: Lazy<B2>)
164 | 
165 | class B2(a2: A2)
166 | 
167 | val module = Module {
168 | 
169 |     singleton { A2(get("lazy B")) }
170 | 
171 |     singleton(name = "lazy B") { lazy { B2(get()) } }
172 | }
173 | 
174 | val component = Component(module)
175 | 
176 | val a: A by component.inject()
177 | ```
178 | 
179 | ## Logging
180 | 
181 | Katana provides a bit of information about dependency declarations and injections during runtime which might help in
182 | debugging DI-related issues. To enable logging pass an implementation of `Katana.Logger` to the `Katana.logger`
183 | property of the `Katana` singleton.
184 | 
185 | ## Installation & Setup
186 | 
187 | Katana is published to Maven Central via Sonatype OSSRH.
188 | 
189 | ```gradle
190 | def katanaVersion = 'LATEST VERSION HERE'
191 | 
192 | dependencies {
193 |     implementation "org.rewedigital.katana:katana-core:${katanaVersion}"
194 |     // Use this artifact for Katana on Android
195 |     implementation "org.rewedigital.katana:katana-android:${katanaVersion}"
196 | }
197 | ```
198 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/ComponentDependsOnTests.kt:
--------------------------------------------------------------------------------
  1 | package org.rewedigital.katana
  2 | 
  3 | import org.amshove.kluent.shouldBeEqualTo
  4 | import org.amshove.kluent.shouldBeInstanceOf
  5 | import org.amshove.kluent.shouldThrow
  6 | import org.rewedigital.katana.dsl.factory
  7 | import org.rewedigital.katana.dsl.get
  8 | import org.spekframework.spek2.Spek
  9 | import org.spekframework.spek2.style.specification.describe
 10 | 
 11 | object ComponentDependsOnTests : Spek(
 12 |     {
 13 |         describe("Injection with multiple components") {
 14 | 
 15 |             it("should inject dependencies") {
 16 |                 val module1 = Module {
 17 | 
 18 |                     factory { "Hello world" }
 19 | 
 20 |                     factory("another") { "Hello world 2" }
 21 |                 }
 22 | 
 23 |                 val component1 = Component(module1)
 24 | 
 25 |                 val module2 = Module {
 26 | 
 27 |                     factory { 1337 }
 28 |                 }
 29 | 
 30 |                 val component2 = Component(module2)
 31 | 
 32 |                 val module3 = Module {
 33 | 
 34 |                     factory { MyComponentC<String, Int>(get(), get()) }
 35 |                 }
 36 | 
 37 |                 val component3 = Component(
 38 |                     modules = listOf(module3),
 39 |                     dependsOn = listOf(component1, component2)
 40 |                 )
 41 | 
 42 |                 component3.canInject<MyComponentC<String, Int>>() shouldBeEqualTo true
 43 |                 component3.canInject<Int>() shouldBeEqualTo true
 44 |                 component3.canInject<String>() shouldBeEqualTo true
 45 |                 component3.canInject<String>("another") shouldBeEqualTo true
 46 |                 component3.canInject<MyComponent>() shouldBeEqualTo false
 47 | 
 48 |                 val myComponent: MyComponentC<String, Int> by component3.inject()
 49 | 
 50 |                 myComponent.value shouldBeEqualTo "Hello world"
 51 |                 myComponent.value2 shouldBeEqualTo 1337
 52 |             }
 53 | 
 54 |             it("should inject dependencies over multiple component tiers") {
 55 | 
 56 |                 val module1 = Module {
 57 | 
 58 |                     factory { "Hello world" }
 59 |                 }
 60 | 
 61 |                 val component1 = Component(module1)
 62 | 
 63 |                 val component2 = Component(component1)
 64 | 
 65 |                 val module3 = Module {
 66 | 
 67 |                     factory { 1337 }
 68 |                 }
 69 | 
 70 |                 val component3 = Component(
 71 |                     modules = listOf(module3),
 72 |                     dependsOn = listOf(component2)
 73 |                 )
 74 | 
 75 |                 component3.canInject<String>() shouldBeEqualTo true
 76 |                 component3.canInject<Int>() shouldBeEqualTo true
 77 |                 val string: String by component3.inject()
 78 |                 val int: Int by component3.inject()
 79 | 
 80 |                 string shouldBeEqualTo "Hello world"
 81 |                 int shouldBeEqualTo 1337
 82 |             }
 83 | 
 84 |             it("should throw override exception for overrides in components") {
 85 | 
 86 |                 val module1 = Module {
 87 | 
 88 |                     factory<MyComponent> { MyComponentA() }
 89 |                 }
 90 | 
 91 |                 val component1 = Component(module1)
 92 | 
 93 |                 val module2 = Module("module1") {
 94 | 
 95 |                     factory<MyComponent> { MyComponentA() }
 96 |                 }
 97 | 
 98 |                 val component2 = Component(module2)
 99 | 
100 |                 val module3 = Module {
101 | 
102 |                     factory { "Hello world" }
103 |                 }
104 | 
105 |                 val fn = {
106 |                     Component(
107 |                         modules = listOf(module3),
108 |                         dependsOn = listOf(component1, component2)
109 |                     )
110 |                 }
111 | 
112 |                 fn shouldThrow OverrideException::class
113 |             }
114 | 
115 |             it("should inject null values over multiple component tiers") {
116 | 
117 |                 val module = Module {
118 | 
119 |                     factory<MyComponent?> { null }
120 |                 }
121 | 
122 |                 val component = Component(module)
123 |                 val component2 = Component(component)
124 | 
125 |                 val injection: MyComponent? = component2.injectNow()
126 | 
127 |                 injection shouldBeEqualTo null
128 |             }
129 | 
130 |             it("should not inject internal bindings over multiple component tiers") {
131 |                 val module = Module {
132 | 
133 |                     factory(name = "internal", internal = true) { "Hello world" }
134 | 
135 |                     factory<MyComponent> { MyComponentB<String>(get("internal")) }
136 |                 }
137 | 
138 |                 val component = Component(module)
139 |                 val component2 = Component(component)
140 | 
141 |                 component2.canInject<String>("internal") shouldBeEqualTo false
142 |                 component2.canInject<MyComponent>() shouldBeEqualTo true
143 | 
144 |                 component2.injectNow<MyComponent>() shouldBeInstanceOf MyComponentB::class
145 | 
146 |                 val fn = {
147 |                     component2.injectNow<String>("internal")
148 |                 }
149 | 
150 |                 fn shouldThrow InjectionException::class
151 |             }
152 | 
153 |             it("plus operator should work as expected") {
154 | 
155 |                 val module1 = Module {
156 | 
157 |                     factory { "Hello world" }
158 |                 }
159 | 
160 |                 val module2 = Module {
161 | 
162 |                     factory { 1234 }
163 |                 }
164 | 
165 |                 val module3 = Module {
166 | 
167 |                     factory("NAME") { 4321 }
168 |                 }
169 | 
170 |                 val module4 = Module {
171 | 
172 |                     factory("NAME2") { 1337 }
173 |                 }
174 | 
175 |                 val component1 = Component(module1)
176 |                 val component2 = component1 + listOf(module2)
177 |                 val component3 = component1 + module2
178 | 
179 |                 component2.injectNow<String>() shouldBeEqualTo "Hello world"
180 |                 component2.injectNow<Int>() shouldBeEqualTo 1234
181 | 
182 |                 component3.injectNow<String>() shouldBeEqualTo "Hello world"
183 |                 component3.injectNow<Int>() shouldBeEqualTo 1234
184 | 
185 |                 val component4 = Component(module3)
186 |                 val component5 = listOf(component2, component4) + listOf(module4)
187 |                 val component6 = listOf(component2, component4) + module4
188 | 
189 |                 component5.injectNow<String>() shouldBeEqualTo "Hello world"
190 |                 component5.injectNow<Int>() shouldBeEqualTo 1234
191 |                 component5.injectNow<Int>("NAME") shouldBeEqualTo 4321
192 |                 component5.injectNow<Int>("NAME2") shouldBeEqualTo 1337
193 | 
194 |                 component6.injectNow<String>() shouldBeEqualTo "Hello world"
195 |                 component6.injectNow<Int>() shouldBeEqualTo 1234
196 |                 component6.injectNow<Int>("NAME") shouldBeEqualTo 4321
197 |                 component6.injectNow<Int>("NAME2") shouldBeEqualTo 1337
198 |             }
199 | 
200 |             // TODO: Fix this
201 |             xit("should allow \"empty\" component when it only has transitive dependencies") {
202 | 
203 |                 val module = Module {
204 | 
205 |                     factory { "Hello world" }
206 |                 }
207 | 
208 |                 val component = Component(module)
209 |                 val component2 = Component(component)
210 |                 val component3 = Component(component2)
211 | 
212 |                 val injection: String = component3.injectNow()
213 | 
214 |                 injection shouldBeEqualTo "Hello world"
215 |             }
216 |         }
217 |     })
218 | 


--------------------------------------------------------------------------------
/core/src/test/kotlin/org/rewedigital/katana/SetTests.kt:
--------------------------------------------------------------------------------
  1 | package org.rewedigital.katana
  2 | 
  3 | import org.amshove.kluent.shouldBeEqualTo
  4 | import org.amshove.kluent.shouldContain
  5 | import org.amshove.kluent.shouldHaveSize
  6 | import org.amshove.kluent.shouldThrow
  7 | import org.rewedigital.katana.dsl.factory
  8 | import org.rewedigital.katana.dsl.get
  9 | import org.rewedigital.katana.dsl.set
 10 | import org.rewedigital.katana.dsl.singleton
 11 | import org.spekframework.spek2.Spek
 12 | import org.spekframework.spek2.style.specification.describe
 13 | 
 14 | object SetTests : Spek(
 15 |     {
 16 |         describe("Set bindings") {
 17 | 
 18 |             it("should provide set injection") {
 19 |                 val myComponent1 = MyComponentA()
 20 |                 val myComponent2 = MyComponentB("hello")
 21 | 
 22 |                 val module = Module {
 23 |                     set<MyComponent> {
 24 |                         factory { myComponent1 }
 25 |                         factory { myComponent2 }
 26 |                         factory { myComponent1 }
 27 |                     }
 28 |                 }
 29 | 
 30 |                 val component = Component(module)
 31 |                 val set: Set<MyComponent> = component.injectNow()
 32 | 
 33 |                 set shouldHaveSize 2
 34 |                 set shouldContain myComponent1
 35 |                 set shouldContain myComponent2
 36 |             }
 37 | 
 38 |             it("should provide named set injection") {
 39 |                 val module = Module {
 40 |                     set<String>(name = "a set") {
 41 |                         factory { "Hello" }
 42 |                         factory { "World" }
 43 |                     }
 44 |                 }
 45 | 
 46 |                 val component = Component(module)
 47 |                 val set: Set<String> = component.injectNow(name = "a set")
 48 | 
 49 |                 set shouldHaveSize 2
 50 |                 set shouldContain "Hello"
 51 |                 set shouldContain "World"
 52 |             }
 53 | 
 54 |             it("should provide set injection across modules") {
 55 |                 val module1 = Module {
 56 |                     set<String> {
 57 |                         factory { "Hello" }
 58 |                     }
 59 |                 }
 60 | 
 61 |                 val module2 = Module {
 62 |                     set<String> {
 63 |                         factory { "World" }
 64 |                     }
 65 |                 }
 66 | 
 67 |                 val component = Component(modules = listOf(module1, module2))
 68 |                 val set: Set<String> = component.injectNow()
 69 | 
 70 |                 set shouldHaveSize 2
 71 |                 set shouldContain "Hello"
 72 |                 set shouldContain "World"
 73 |             }
 74 | 
 75 |             it("should provide named set injection across modules") {
 76 |                 val module1 = Module {
 77 |                     set<String>(name = "a set") {
 78 |                         factory { "Hello" }
 79 |                     }
 80 | 
 81 |                     set<String>(name = "another set") {
 82 |                         factory { "Hello 2" }
 83 |                     }
 84 |                 }
 85 | 
 86 |                 val module2 = Module {
 87 |                     set<String>(name = "a set") {
 88 |                         factory { "World" }
 89 |                     }
 90 |                 }
 91 | 
 92 |                 val component = Component(modules = listOf(module1, module2))
 93 |                 val set: Set<String> = component.injectNow(name = "a set")
 94 | 
 95 |                 set shouldHaveSize 2
 96 |                 set shouldContain "Hello"
 97 |                 set shouldContain "World"
 98 |             }
 99 | 
100 |             it("should provide set injection across components") {
101 |                 val module1 = Module {
102 |                     set<String> {
103 |                         factory { "Hello" }
104 |                     }
105 |                 }
106 | 
107 |                 val module2 = Module {
108 |                     set<String> {
109 |                         factory { "World" }
110 |                     }
111 |                 }
112 | 
113 |                 val component1 = Component(module1)
114 |                 val component2 = Component(modules = listOf(module2), dependsOn = listOf(component1))
115 |                 val set1: Set<String> = component1.injectNow()
116 |                 val set2: Set<String> = component2.injectNow()
117 | 
118 |                 set1 shouldHaveSize 1
119 |                 set1 shouldContain "Hello"
120 | 
121 |                 set2 shouldHaveSize 2
122 |                 set2 shouldContain "Hello"
123 |                 set2 shouldContain "World"
124 |             }
125 | 
126 |             it("should not allow set redeclaration in same module") {
127 |                 val fn = {
128 |                     Module {
129 |                         set<String> {
130 |                             factory { "Hello" }
131 |                         }
132 | 
133 |                         set<String> {
134 |                             factory { "World" }
135 |                         }
136 |                     }
137 |                 }
138 | 
139 |                 fn shouldThrow OverrideException::class
140 |             }
141 | 
142 |             it("should facilitate singletons in sets") {
143 |                 var count1 = 0
144 |                 var count2 = 0
145 | 
146 |                 val module1 = Module {
147 |                     set<MyComponent> {
148 |                         singleton {
149 |                             count1++
150 |                             MyComponentA()
151 |                         }
152 |                         factory { MyComponentB("hello") }
153 |                     }
154 |                 }
155 | 
156 |                 val module2 = Module {
157 |                     set<MyComponent> {
158 |                         singleton {
159 |                             count2++
160 |                             MyComponentA()
161 |                         }
162 |                     }
163 |                 }
164 | 
165 |                 val component = Component(modules = listOf(module1, module2))
166 |                 component.injectNow<Set<MyComponent>>()
167 |                 val set1: Set<MyComponent> = component.injectNow()
168 |                 val set2: Set<MyComponent> = component.injectNow()
169 | 
170 |                 (set1 === set2) shouldBeEqualTo false
171 |                 count1 shouldBeEqualTo 1
172 |                 count2 shouldBeEqualTo 1
173 |             }
174 | 
175 |             it("should locate dependencies declared in outer scope via factory") {
176 |                 val module = Module {
177 |                     factory(name = "outer scope") { "Hello world" }
178 | 
179 |                     set<String> {
180 |                         factory { get(name = "outer scope") }
181 |                     }
182 |                 }
183 |                 val component = Component(module)
184 |                 val set: Set<String> = component.injectNow()
185 | 
186 |                 set shouldHaveSize 1
187 |                 set shouldContain "Hello world"
188 |             }
189 | 
190 |             it("should locate dependencies declared in outer scope via get") {
191 |                 val module = Module {
192 |                     factory(name = "outer scope") { "Hello world" }
193 |                     singleton { "Another string" }
194 |                     factory<CharSequence> { "A char sequence" }
195 | 
196 |                     set<CharSequence> {
197 |                         get<CharSequence, String>(name = "outer scope")
198 |                         get<CharSequence, String>()
199 |                         get()
200 |                     }
201 |                 }
202 |                 val component = Component(module)
203 |                 val set: Set<String> = component.injectNow()
204 | 
205 |                 set shouldHaveSize 3
206 |                 set shouldContain "Hello world"
207 |                 set shouldContain "Another string"
208 |                 set shouldContain "A char sequence"
209 |             }
210 |         }
211 |     })
212 | 


--------------------------------------------------------------------------------
/core/src/main/kotlin/org/rewedigital/katana/dsl/Dsl.kt:
--------------------------------------------------------------------------------
  1 | package org.rewedigital.katana.dsl
  2 | 
  3 | import org.rewedigital.katana.*
  4 | import org.rewedigital.katana.dsl.internal.declaration
  5 | 
  6 | /**
  7 |  * Declares a dependency binding.
  8 |  * A new instance will be created every time the dependency is requested.
  9 |  *
 10 |  * @param name Optional name of binding. See documentation of package [org.rewedigital.katana] for more details.
 11 |  * @param internal If `true` binding is only available in current module
 12 |  * @param body Body of binding declaration
 13 |  *
 14 |  * @see ModuleBindingContext.singleton
 15 |  * @see ModuleBindingContext.eagerSingleton
 16 |  */
 17 | inline fun <reified T> ModuleBindingContext.factory(
 18 |     name: Any? = null,
 19 |     internal: Boolean = false,
 20 |     noinline body: ProviderDsl.() -> T
 21 | ) =
 22 |     declaration(
 23 |         context = this,
 24 |         clazz = T::class.java,
 25 |         name = name,
 26 |         internal = internal,
 27 |         type = Declaration.Type.FACTORY,
 28 |         provider = DefaultProvider(body)
 29 |     )
 30 | 
 31 | /**
 32 |  * Declares a dependency binding as a singleton.
 33 |  * Only one instance (per component) will be created.
 34 |  *
 35 |  * @param name Optional name of binding. See documentation of package [org.rewedigital.katana] for more details.
 36 |  * @param internal If `true` binding is only available in current module
 37 |  * @param body Body of binding declaration
 38 |  *
 39 |  * @see ModuleBindingContext.factory
 40 |  * @see ModuleBindingContext.eagerSingleton
 41 |  */
 42 | inline fun <reified T> ModuleBindingContext.singleton(
 43 |     name: Any? = null,
 44 |     internal: Boolean = false,
 45 |     noinline body: ProviderDsl.() -> T
 46 | ) =
 47 |     declaration(
 48 |         context = this,
 49 |         clazz = T::class.java,
 50 |         name = name,
 51 |         internal = internal,
 52 |         type = Declaration.Type.SINGLETON,
 53 |         provider = DefaultProvider(body)
 54 |     )
 55 | 
 56 | /**
 57 |  * Declares a dependency binding as a eager singleton.
 58 |  * Only once instance (per component) will be created.
 59 |  * The instance will be created when the [Component] is created and not lazily the first time it's requested.
 60 |  *
 61 |  * @param name Optional name of binding. See documentation of package [org.rewedigital.katana] for more details.
 62 |  * @param internal If `true` binding is only available in current module
 63 |  * @param body Body of binding declaration
 64 |  *
 65 |  * @see ModuleBindingContext.factory
 66 |  * @see ModuleBindingContext.singleton
 67 |  */
 68 | inline fun <reified T> ModuleBindingContext.eagerSingleton(
 69 |     name: Any? = null,
 70 |     internal: Boolean = false,
 71 |     noinline body: ProviderDsl.() -> T
 72 | ) =
 73 |     declaration(
 74 |         context = this,
 75 |         clazz = T::class.java,
 76 |         name = name,
 77 |         internal = internal,
 78 |         type = Declaration.Type.EAGER_SINGLETON,
 79 |         provider = DefaultProvider(body)
 80 |     )
 81 | 
 82 | /**
 83 |  * Declares an alias of type [A] with optional [name] of an already existing binding of type [T] with optional name
 84 |  * [originalName]. An alias is accomplished by and nothing else than a simple [factory] binding.
 85 |  *
 86 |  * A binding like `alias<MyInterface, MyClass>()` should be conceived as "create alias MyInterface for MyClass".
 87 |  */
 88 | inline fun <reified A, reified T : A> ModuleBindingContext.alias(
 89 |     name: Any? = null,
 90 |     originalName: Any? = null
 91 | ) {
 92 |     factory<A>(name = name) { get<T>(name = originalName) }
 93 | }
 94 | 
 95 | /**
 96 |  * Declares a [Set] based multi-binding.
 97 |  *
 98 |  * Each [SetBindingContext.factory] or [SetBindingContext.singleton] declaration inside `set { }` contributes
 99 |  * to the set.
100 |  *
101 |  * Multiple set bindings of the same **unique** type across different modules and components are conflated into a single
102 |  * [Set] during injection.
103 |  *
104 |  * Example:
105 |  *
106 |  * ```
107 |  * val module1 = Module {
108 |  *   set<String> {
109 |  *     factory { "Hello" }
110 |  *   }
111 |  * }
112 |  *
113 |  * val module2 = Module {
114 |  *   set<String> {
115 |  *      factory { "World" }
116 |  *   }
117 |  * }
118 |  *
119 |  * val component = Component(modules = listOf(module1, module2))
120 |  * val set: Set<String> = component.injectNow() // == setOf("Hello", "World")
121 |  * ```
122 |  *
123 |  * Due to the nature of multi-bindings, singletons declared inside a set are unique per [Module] set declaration
124 |  * **and** [Component]. This means that a set-singleton declared in `module1` and another set-singleton declared in
125 |  * `module2` for the same unique set will result in two singleton instances if both modules are part of the same
126 |  * [Component].
127 |  *
128 |  * @param name Optional name of binding. See documentation of package [org.rewedigital.katana] for more details.
129 |  *
130 |  * @see SetBindingContext.factory
131 |  * @see SetBindingContext.singleton
132 |  */
133 | inline fun <reified T> ModuleBindingContext.set(
134 |     name: Any? = null,
135 |     body: SetBindingContext<T>.() -> Unit
136 | ) =
137 |     internalSet(
138 |         name = name,
139 |         body = body
140 |     )
141 | 
142 | /**
143 |  * internalSet required because of two reified type parameters,
144 |  * where `S` however can be inferred by compiler in call of [set].
145 |  */
146 | @PublishedApi
147 | internal inline fun <reified T, reified S : Set<T>> ModuleBindingContext.internalSet(
148 |     name: Any? = null,
149 |     body: SetBindingContext<T>.() -> Unit
150 | ) =
151 |     also {
152 |         SetBindingContext<T>(
153 |             module = module,
154 |             key = Key.of(clazz = T::class.java, name = name)
155 |         ).let { bindingContext ->
156 |             declaration(
157 |                 context = this,
158 |                 clazz = S::class.java,
159 |                 name = name,
160 |                 internal = false,
161 |                 type = Declaration.Type.SET,
162 |                 provider = SetProvider(bindingContext.key)
163 |             )
164 | 
165 |             body.invoke(bindingContext)
166 |         }
167 |     }
168 | 
169 | inline fun <reified T> SetBindingContext<T>.factory(
170 |     noinline body: ProviderDsl.() -> T
171 | ) =
172 |     declaration(
173 |         context = this,
174 |         clazz = T::class.java,
175 |         name = null,
176 |         internal = false,
177 |         type = Declaration.Type.FACTORY,
178 |         provider = DefaultProvider(body)
179 |     )
180 | 
181 | inline fun <reified T> SetBindingContext<T>.singleton(
182 |     noinline body: ProviderDsl.() -> T
183 | ) =
184 |     declaration(
185 |         context = this,
186 |         clazz = T::class.java,
187 |         name = null,
188 |         internal = false,
189 |         type = Declaration.Type.SINGLETON,
190 |         provider = DefaultProvider(body)
191 |     )
192 | 
193 | /**
194 |  * Adds an already declared dependency in the context of the [Module] to this [Set].
195 |  *
196 |  * @param T type of the set
197 |  * @param V type of the value added to the set
198 |  */
199 | inline fun <T, reified V : T> SetBindingContext<T>.get(
200 |     name: Any? = null
201 | ) = declaration(
202 |     context = this,
203 |     clazz = V::class.java,
204 |     name = name,
205 |     internal = false,
206 |     type = Declaration.Type.CUSTOM,
207 |     provider = object : Provider<V> {
208 |         override fun invoke(context: ComponentContext, arg: Any?): V =
209 |             context.injectNow(name = name)
210 |     }
211 | )
212 | 
213 | /**
214 |  * Declares a custom binding with a custom implementation of [Provider].
215 |  *
216 |  * A custom provider might for instance handle additional arguments passed to [Provider.invoke].
217 |  * This should rarely be used and is rather meant for Katana extensions!
218 |  *
219 |  * @see Component.custom
220 |  */
221 | inline fun <reified T> ModuleBindingContext.custom(
222 |     name: Any? = null,
223 |     internal: Boolean = false,
224 |     provider: Provider<T>
225 | ) =
226 |     declaration(
227 |         context = this,
228 |         clazz = T::class.java,
229 |         name = name,
230 |         internal = internal,
231 |         type = Declaration.Type.CUSTOM,
232 |         provider = provider
233 |     )
234 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | ## Version 1.15.0
  2 | 
  3 | _2021-05-06_
  4 | 
  5 | This is a maintenance release, just updating a few dependencies:
  6 | 
  7 | * Kotlin 1.5.0
  8 | * Android Gradle Plugin 4.2.0
  9 | * JDK 11
 10 | * ...and a few more
 11 | 
 12 | ## Version 1.14.1
 13 | 
 14 | _2021-02-08_
 15 | 
 16 | This is a maintenance release, just updating a few dependencies:
 17 | 
 18 | * Kotlin 1.4.20
 19 | * Android Gradle Plugin 4.1.2
 20 | * Android build tools 30.0.3
 21 | 
 22 | ## Version 1.14.0
 23 | 
 24 | _2020-09-11_
 25 | 
 26 | This is a maintenance release, just updating a few dependencies:
 27 | 
 28 | * Kotlin 1.4.0
 29 | * Android Gradle Plugin 4.0.1
 30 | * Android (target|compile)SdkVersion 30 (Android 11)
 31 | * Android build tools 30.0.2
 32 | * `androidx.fragment:fragment` 1.2.5
 33 | 
 34 | ## Version 1.13.2
 35 | 
 36 | _2020-05-06_
 37 | 
 38 | * Update dependencies
 39 |   * Kotlin 1.3.72
 40 |   * androidx.fragment 1.2.4
 41 | 
 42 | ## Version 1.13.1
 43 | 
 44 | _2020-03-04_
 45 | 
 46 | * Update dependencies
 47 |   * Kotlin 1.3.70
 48 |   * androidx.fragment 1.2.2
 49 | 
 50 | ## Version 1.13
 51 | 
 52 | _2020-02-17_
 53 | 
 54 | * Add `provider()` to `Module` DSL
 55 | 
 56 | ## Version 1.12.1
 57 | 
 58 | _2020-01-29_
 59 | 
 60 | * Bugfix: `alias()` & set-related `get()` name arguments were limited to `String` but should be `Any`
 61 | 
 62 | ## Version 1.12.0
 63 | 
 64 | _2020-01-27_
 65 | 
 66 | * Update `androidx.lifecycle:lifecycle-viewmodel` dependency to version 2.2.0
 67 | * Update `androidx.lifecycle:lifecycle-viewmodel-savedstate` dependency to first stable version 1.0.0
 68 | 
 69 | ## Version 1.11.0
 70 | 
 71 | _2020-01-23_
 72 | 
 73 | * Add support for Fragment instantiation through Katana with new artifact `katana-androidx-fragment` and 
 74 | [KatanaFragmentFactory](./androidx-fragment/src/main/kotlin/org/rewedigital/katana/androidx/fragment/KatanaFragmentFactory.kt)
 75 | (also see [FragmentFactory](https://developer.android.com/reference/androidx/fragment/app/FragmentFactory) of `androidx.fragment:fragment:1.2.0`) 
 76 | 
 77 | ## Version 1.10.0
 78 | 
 79 | _2020-01-03_
 80 | 
 81 | Happy New Year 🎉
 82 | 
 83 | * Add optional injection via injectOrNull() / getOrNull()
 84 | 
 85 | ## Version 1.9.0
 86 | 
 87 | _2019-12-04_
 88 | 
 89 | With this release Santa Claus is bringing some premature Christmas presents 😉
 90 | 
 91 | * Add `alias` keyword for binding an existing declaration under a different type and/or name
 92 | * Add `get` keyword inside `set` declaration for assigning an existing dependency to a set 
 93 | * Update Kotlin to 1.3.61
 94 | * Remove deprecated functions &amp; features
 95 | 
 96 | Special thanks to @dave08 for feature requests &amp; feedback 🙂  
 97 | Wishing all users happy holidays &amp; a happy new year! 🎉
 98 | 
 99 | ## Version 1.8.3
100 | 
101 | _2019-10-21_
102 | 
103 | * Bugfix: Fixed bug introduced in 1.8.2 regarding Activity ViewModel injection
104 | 
105 | ## Version 1.8.2
106 | 
107 | _2019-10-21_
108 | 
109 | * AndroidX ViewModel support: Remove usage of deprecated `lifecycle-extensions`
110 | 
111 | ## Version 1.8.1
112 | 
113 | _2019-10-18_
114 | 
115 | * Rename module factory functions of `katana-android` artifact
116 | * Update AndroidX Lifecycle and ViewModel dependencies
117 | 
118 | ## Version 1.8.0
119 | 
120 | _2019-10-10_
121 | 
122 | * Add `set` multi-binding functionality
123 | * Remove deprecated functions
124 | * Deprecate old DSL and promote "compact" DSL to default DSL
125 | * **Note:** Changes of this version are source but **not binary** compatible!
126 | 
127 | ## Version 1.7.1
128 | 
129 | _2019-08-29_
130 | 
131 | * Update dependencies (Kotlin 1.3.50)
132 | * Update `lifecycle-viewmodel-savedstate` to 1.0.0-alpha03
133 | 
134 | ## Version 1.7.0
135 | 
136 | _2019-06-05_
137 | 
138 | * Add experimental support for ViewModel injection with [saved state](https://developer.android.com/topic/libraries/architecture/viewmodel-savedstate).  
139 |   Please use artifact `org.rewedigital.katana:katana-androidx-viewmodel-savedstate:1.7.0-alpha01`.
140 | 
141 | ## Version 1.6.3
142 | 
143 | _2019-05-16_
144 | 
145 | * Add `Component.Builder` pattern
146 | * Downgrade Android plugin to 3.3.2 (workaround for issue #7)
147 | 
148 | ## Version 1.6.2
149 | 
150 | _2019-04-29_
151 | 
152 | * `savedInstanceState` is passed to `KatanaFragment(Delegate)` 
153 | * Kotlin dependency has been updated to 1.3.31.
154 | 
155 | ## Version 1.6.1
156 | 
157 | _2019-04-23_
158 | 
159 | * Maintenance release. Kotlin dependency has been updated to 1.3.30.
160 | 
161 | ## Version 1.6.0
162 | 
163 | _2019-03-29_
164 | 
165 | * `createModule()` and `createComponent()` have been deprecated. Use constructors of `Module` and `Component` instead. 
166 | 
167 | ## Version 1.5.1
168 | 
169 | _2019-03-28_
170 | 
171 | * Fix initialization of transitive eager singletons
172 | 
173 | ## Version 1.5.0
174 | 
175 | _2019-03-26_
176 | 
177 | * Allow `Any` references for dependency names.  
178 |   Now String constants, Kotlin `object`s, enum classes and custom (data) classes representing a unique identity / 
179 |   equality can be used for names.
180 | * Modules may include other modules during declaration via `includes` attribute.
181 | 
182 | ## Version 1.4.0
183 | 
184 | _2019-03-18_
185 | 
186 | * Add [AndroidX ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel) support via new 
187 |   [katana-androidx-viewmodel](./androidx-viewmodel) artifact.
188 |   
189 |   Thanks to @inshiro for idea & initial code :)
190 | 
191 | ## Version 1.3.0
192 | 
193 | _2019-02-08_
194 | 
195 | * Add a new, compact DSL for module declarations.  
196 |   **Imports must be updated!** Either use `org.rewedigital.katana.dsl.classic` or the new 
197 |   `org.rewedigital.katana.dsl.compact`:
198 |   ```kotlin
199 |   createModule {
200 |     factory { MyDependencyA() }
201 |     singleton { MyDependencyB() }  
202 |   }
203 |   ``` 
204 | * Update Kotlin version to 1.3.21
205 | 
206 | ## Version 1.2.8
207 | 
208 | _2019-02-06_
209 | 
210 | * Add `KatanaFragmentDelegate` and `KatanaFragment` classes to Android artifact
211 |   for simplifying usage of Katana with Fragments.
212 | 
213 | ## Version 1.2.7
214 | 
215 | _2019-02-04_
216 | 
217 | * Implement `+` operator for `Component`, allowing different syntax for creating child components:
218 |   ```kotlin
219 |   val childComponent = component + childModule
220 |   // or
221 |   val childComponent = component + listOf(childModule1, childModule2)
222 |   // or
223 |   val childComponent = listOf(component1, component2) + childModule
224 |   ```
225 | 
226 | ## Version 1.2.6
227 | 
228 | _2019-01-25_
229 | 
230 | * Update Kotlin version to 1.3.20
231 | 
232 | ## Version 1.2.5
233 | 
234 | _2019-01-21_
235 | 
236 | * First version deployed on [JCenter](https://bintray.com/bintray/jcenter)
237 | * No code changes
238 | 
239 | ## Version 1.2.4
240 | 
241 | _2019-01-09_
242 | 
243 | * Fix wrong `OverrideException` for internal module declarations
244 | * Permit `null` values of (eager) singletons
245 | 
246 | ## Version 1.2.3
247 | 
248 | _2018-12-19_
249 | 
250 | * Permit injection of `null` values
251 | * Permit internal module bindings
252 | 
253 | ## Version 1.2.2
254 | 
255 | _2018-12-17_
256 | 
257 | * Improve injection performance
258 | 
259 | ## Version 1.2.1
260 | 
261 | _2018-12-14_
262 | 
263 | * Add `MEMORY` and `SPEED` profiles to `AndroidEnvironmentContext`.
264 |   Either choose between optimization of memory consumption or execution speed.
265 | 
266 | ## Version 1.2.0
267 | 
268 | _2018-12-14_
269 | 
270 | * Add pluggable `EnvironmentContext` for optimizing Katana for specific runtime environments.
271 |   See [Android implementation](android/README.md).
272 | * [Android](android) artifact is now an Android library (AAR) with a dependency on [AndroidX](https://developer.android.com/jetpack/androidx/).
273 | * Android artifact provides module factory functions for support `Fragments`.
274 | 
275 | ## Version 1.1.0
276 | 
277 | _2018-12-07_
278 | 
279 | * Convert module DSL functions to extension functions for better code highlighting/readability.
280 |   This is a **breaking change** as `bind()`, `factory()` etc. now have to be imported!
281 | 
282 | ## Version 1.0.2
283 | 
284 | _2018-12-07_
285 | 
286 | * Add Android module factory functions to Android artifact
287 | * Update Kotlin version to 1.3.11
288 | 
289 | ## Version 1.0.1
290 | 
291 | _2018-10-31_
292 | 
293 | * Update Kotlin dependency to 1.3 
294 | 
295 | ## Version 1.0
296 | 
297 | _2018-10-29_
298 | 
299 | * First public release
300 | 


--------------------------------------------------------------------------------
/androidx-viewmodel-savedstate/src/main/kotlin/org/rewedigital/katana/androidx/viewmodel/savedstate/ViewModelSavedState.kt:
--------------------------------------------------------------------------------
  1 | @file:Suppress("unused")
  2 | 
  3 | package org.rewedigital.katana.androidx.viewmodel.savedstate
  4 | 
  5 | import android.os.Bundle
  6 | import androidx.fragment.app.Fragment
  7 | import androidx.fragment.app.FragmentActivity
  8 | import androidx.lifecycle.*
  9 | import androidx.savedstate.SavedStateRegistryOwner
 10 | import org.rewedigital.katana.*
 11 | import org.rewedigital.katana.androidx.viewmodel.internal.viewModelName
 12 | import org.rewedigital.katana.androidx.viewmodel.savedstate.SavedStateViewModelKatanaProvider.Arg
 13 | import org.rewedigital.katana.dsl.ProviderDsl
 14 | import org.rewedigital.katana.dsl.custom
 15 | 
 16 | internal class KatanaSavedStateViewModelFactory(
 17 |     owner: SavedStateRegistryOwner,
 18 |     defaultArgs: Bundle?,
 19 |     private val viewModelProvider: (state: SavedStateHandle) -> ViewModel
 20 | ) : AbstractSavedStateViewModelFactory(owner, defaultArgs) {
 21 | 
 22 |     @Suppress("UNCHECKED_CAST")
 23 |     override fun <VM : ViewModel> create(key: String, modelClass: Class<VM>, handle: SavedStateHandle): VM =
 24 |         viewModelProvider(handle) as VM
 25 | }
 26 | 
 27 | internal object InternalSavedStateViewModelProvider {
 28 | 
 29 |     fun <VM : ViewModel> of(
 30 |         viewModelStoreOwner: ViewModelStoreOwner,
 31 |         savedStateRegistryOwner: SavedStateRegistryOwner,
 32 |         key: String?,
 33 |         defaultArgs: Bundle?,
 34 |         viewModelClass: Class<VM>,
 35 |         viewModelProvider: (state: SavedStateHandle) -> ViewModel
 36 |     ) =
 37 |         ViewModelProvider(
 38 |             viewModelStoreOwner,
 39 |             KatanaSavedStateViewModelFactory(
 40 |                 savedStateRegistryOwner,
 41 |                 defaultArgs,
 42 |                 viewModelProvider
 43 |             )
 44 |         ).internalGet(key, viewModelClass)
 45 | 
 46 |     private fun <VM : ViewModel> ViewModelProvider.internalGet(key: String?, viewModelClass: Class<VM>) =
 47 |         if (key == null)
 48 |             get(viewModelClass)
 49 |         else
 50 |             get(key, viewModelClass)
 51 | }
 52 | 
 53 | @PublishedApi
 54 | internal class SavedStateViewModelKatanaProvider<VM : ViewModel>(
 55 |     private val body: ProviderDsl.(state: SavedStateHandle) -> VM,
 56 |     private val defaultArgs: Bundle?,
 57 |     private val viewModelClass: Class<VM>
 58 | ) : Provider<VM> {
 59 | 
 60 |     data class Arg(
 61 |         val key: String?,
 62 |         val viewModelStoreOwner: ViewModelStoreOwner,
 63 |         val savedStateRegistryOwner: SavedStateRegistryOwner
 64 |     )
 65 | 
 66 |     override operator fun invoke(context: ComponentContext, arg: Any?): VM =
 67 |         when (arg) {
 68 |             is Arg -> InternalSavedStateViewModelProvider.of(
 69 |                 viewModelStoreOwner = arg.viewModelStoreOwner,
 70 |                 savedStateRegistryOwner = arg.savedStateRegistryOwner,
 71 |                 key = arg.key,
 72 |                 defaultArgs = defaultArgs,
 73 |                 viewModelClass = viewModelClass,
 74 |                 viewModelProvider = { state -> body.invoke(ProviderDsl(context), state) }
 75 |             )
 76 |             else -> throw KatanaException(message = "Unknown argument passed to SavedStateViewModelKatanaProvider")
 77 |         }
 78 | }
 79 | 
 80 | //<editor-fold desc="Module DSL">
 81 | /**
 82 |  * Declares a [ViewModel] dependency binding with a [SavedStateHandle].
 83 |  *
 84 |  * The saved state is passed to the provider body as an argument which then can be passed to the ViewModel instance
 85 |  * when created.
 86 |  *
 87 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
 88 |  * @param defaultArgs Optional default args that are passed to [AbstractSavedStateViewModelFactory]
 89 |  */
 90 | inline fun <reified VM : ViewModel> ModuleBindingContext.viewModelSavedState(
 91 |     key: String? = null,
 92 |     defaultArgs: Bundle? = null,
 93 |     noinline body: ProviderDsl.(state: SavedStateHandle) -> VM
 94 | ) =
 95 |     custom(
 96 |         name = viewModelName(modelClass = VM::class.java, key = key),
 97 |         provider = SavedStateViewModelKatanaProvider(
 98 |             body = body,
 99 |             defaultArgs = defaultArgs,
100 |             viewModelClass = VM::class.java
101 |         )
102 |     )
103 | 
104 | /**
105 |  * Provides [ViewModel] instance with a [SavedStateHandle] declared in current injection context.
106 |  */
107 | inline fun <reified VM : ViewModel, OWNER> ProviderDsl.viewModelSavedState(owner: OWNER, key: String? = null)
108 |         where OWNER : ViewModelStoreOwner, OWNER : SavedStateRegistryOwner =
109 |     context.custom<VM>(
110 |         name = viewModelName(VM::class.java, key),
111 |         arg = Arg(
112 |             key = key,
113 |             viewModelStoreOwner = owner,
114 |             savedStateRegistryOwner = owner
115 |         )
116 |     )
117 | 
118 | /**
119 |  * Provides [Fragment] [ViewModel] instance with a [SavedStateHandle] scoped to its [FragmentActivity] declared in current injection context.
120 |  */
121 | inline fun <reified VM : ViewModel> ProviderDsl.activityViewModelSavedState(fragment: Fragment, key: String? = null) =
122 |     viewModelSavedState<VM, FragmentActivity>(owner = fragment.requireActivity(), key = key)
123 | //</editor-fold>
124 | 
125 | //<editor-fold desc="Injection extension functions">
126 | /**
127 |  * Immediately injects [ViewModel] with a [SavedStateHandle].
128 |  *
129 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
130 |  *
131 |  * @see ModuleBindingContext.viewModelSavedState
132 |  */
133 | inline fun <reified VM : ViewModel, OWNER> Component.viewModelSavedStateNow(owner: OWNER, key: String? = null)
134 |         where OWNER : ViewModelStoreOwner, OWNER : SavedStateRegistryOwner =
135 |     custom<VM>(
136 |         name = viewModelName(VM::class.java, key),
137 |         arg = Arg(
138 |             key = key,
139 |             viewModelStoreOwner = owner,
140 |             savedStateRegistryOwner = owner
141 |         )
142 |     )
143 | 
144 | @PublishedApi
145 | internal inline fun <reified VM : ViewModel, OWNER> Component.internalViewModelSavedState(
146 |     noinline ownerProvider: () -> OWNER,
147 |     key: String? = null
148 | ) where OWNER : ViewModelStoreOwner, OWNER : SavedStateRegistryOwner =
149 |     lazy { viewModelSavedStateNow<VM, OWNER>(ownerProvider(), key) }
150 | 
151 | /**
152 |  * Injects [ViewModel] with a [SavedStateHandle].
153 |  *
154 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
155 |  *
156 |  * @see ModuleBindingContext.viewModelSavedState
157 |  */
158 | inline fun <reified VM : ViewModel, OWNER> Component.viewModelSavedState(owner: OWNER, key: String? = null)
159 |         where OWNER : ViewModelStoreOwner, OWNER : SavedStateRegistryOwner =
160 |     internalViewModelSavedState<VM, OWNER>(ownerProvider = { owner }, key = key)
161 | 
162 | /**
163 |  * Immediately injects [ViewModel] with a [SavedStateHandle] of current owner implementing [KatanaTrait] interface.
164 |  *
165 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
166 |  *
167 |  * @see ModuleBindingContext.viewModelSavedState
168 |  */
169 | inline fun <reified VM : ViewModel, T> T.viewModelSavedStateNow(key: String? = null)
170 |         where T : KatanaTrait, T : ViewModelStoreOwner, T : SavedStateRegistryOwner =
171 |     component.viewModelSavedStateNow<VM, T>(this, key)
172 | 
173 | /**
174 |  * Injects [ViewModel] with a [SavedStateHandle] of current owner implementing [KatanaTrait] interface.
175 |  *
176 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
177 |  *
178 |  * @see ModuleBindingContext.viewModelSavedState
179 |  */
180 | inline fun <reified VM : ViewModel, T> T.viewModelSavedState(key: String? = null)
181 |         where T : KatanaTrait, T : ViewModelStoreOwner, T : SavedStateRegistryOwner =
182 |     component.viewModelSavedState<VM, T>(this, key)
183 | 
184 | /**
185 |  * Immediately injects [ViewModel] with a [SavedStateHandle] of specified [Fragment] scoped to its [FragmentActivity].
186 |  *
187 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
188 |  *
189 |  * @see ModuleBindingContext.viewModelSavedState
190 |  */
191 | inline fun <reified VM : ViewModel> Component.activityViewModelSavedStateNow(fragment: Fragment, key: String? = null) =
192 |     viewModelSavedStateNow<VM, FragmentActivity>(
193 |         owner = fragment.requireActivity(),
194 |         key = key
195 |     )
196 | 
197 | /**
198 |  * Injects [ViewModel] with a [SavedStateHandle] of specified [Fragment] scoped to its [FragmentActivity].
199 |  *
200 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
201 |  *
202 |  * @see ModuleBindingContext.viewModelSavedState
203 |  */
204 | inline fun <reified VM : ViewModel> Component.activityViewModelSavedState(fragment: Fragment, key: String? = null) =
205 |     internalViewModelSavedState<VM, FragmentActivity>(
206 |         ownerProvider = { fragment.requireActivity() },
207 |         key = key
208 |     )
209 | 
210 | /**
211 |  * Immediately injects [ViewModel] with a [SavedStateHandle] of current [Fragment] implementing [KatanaTrait] scoped to its [FragmentActivity].
212 |  *
213 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
214 |  *
215 |  * @see ModuleBindingContext.viewModelSavedState
216 |  */
217 | inline fun <reified VM : ViewModel, T> T.activityViewModelSavedStateNow(key: String? = null) where T : KatanaTrait, T : Fragment =
218 |     component.viewModelSavedStateNow<VM, FragmentActivity>(owner = requireActivity(), key = key)
219 | 
220 | /**
221 |  * Injects [ViewModel] with a [SavedStateHandle] of current [Fragment] implementing [KatanaTrait] scoped to its [FragmentActivity].
222 |  *
223 |  * @param key Optional key as required for `ViewModelProvider.get(String, Class)`
224 |  *
225 |  * @see ModuleBindingContext.viewModelSavedState
226 |  */
227 | inline fun <reified VM : ViewModel, T> T.activityViewModelSavedState(key: String? = null) where T : KatanaTrait, T : Fragment =
228 |     component.internalViewModelSavedState<VM, FragmentActivity>(
229 |         ownerProvider = { requireActivity() },
230 |         key = key
231 |     )
232 | //<editor-fold>
233 | 


--------------------------------------------------------------------------------