Winter Dependency Injection

val coffeeAppComponent = component {
    prototype { Heater() }
    prototype<Pump> { RotaryPump() }
    singleton { CoffeeMaker(instance(), instance()) }
}

val coffeeAppComponent = component {
    singleton { HttpCache() }

    subcomponent("gui") {
        singleton { ImageLoader(cache = instance<HttpCache>()) }
    }
}

// initialize the application component
val appGraph = coffeeAppComponent.createGraph()
// open a subgraph
val guiGraph = appGraph.openSubgraph("gui")
// close a subgraph
appGraph.closeSubgraph("gui")
// or
guiGraph.close()

val coffeeAppComponent = component {
    prototype { Heater() }

    prototype { RotaryPump() }

    singleton { CoffeeMaker(instance(), instance()) }
}

val graph = coffeeAppComponent.createGraph()

// get an instance of Heater
val heater: Heater = graph.instance()

// get an optional instance of Heater
val heater: Heater? = graph.instanceOrNull()

// get a provider for Heater
val heaterProvider: () -> Heater = graph.provider()

// get an optional provider for Heater
val heaterProvider: (() -> Heater)? = graph.providerOrNull()

// get a set of instances of type Pump; this is useful when you have registered
// multiple Pumps with different qualifers
val pumps: Set<Pump> = graph.instancesOfType<Pump>()

// get a set of providers for type Pump; this is useful when you have registerd
// multiple Pumps with different qualifers
val pumps: Set<() -> Pump> = graph.providersOfType<Pump>()

val appComponent = component {
    singleton<Collection<TrackingBackend>>(generics = true) {
        listOf(FirebaseTracker(), MixpanelTracker())
    }
    singleton { ScreenTracker(backends = instance(generics = true)) }
}

class MyApplication : Application() {
    override fun onCreate() {
        // declare application component
        Winter.component(ApplicationScope::class) {
            singleton<GitHubApi> { GitHubApiImpl() }

            singleton { RepoListViewModel(instance()) }

            subcomponent(ActivityScope::class) {
                singleton { Glide.with(instance<Activity>()) }
            }
        }

        // Configure the injection adapter to use
        Winter.useSimpleAndroidAdapter()
        // Open the application graph
        Winter.inject(this)
    }
}

class MyActivity : Activity() {
    private val viewModel: RepoListViewModel by inject()
    private val glide: RequestManager by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        Winter.inject(this)
        super.onCreate(savedInstanceState)
    }
}

val coffeeAppComponent = component {
    singleton { Heater() }
    singleton<Pump> { RotaryPump() }
    singleton { CoffeeMaker(instance(), instance()) }
}

val coffeeAppComponent = component {
    singleton { Heater() }
    singleton<Pump> { RotaryPump() }
    singleton {
        val coffeeMaker = CoffeeMaker()
        coffeeMaker.heater = instance()
        coffeeMaker.pump = instance()
        coffeeMaker
    }
}

val coffeeAppComponent = component {
    singleton { Heater() }
    singleton<Pump> { RotaryPump() }
    singleton(
        postConstruct = {
            it.heater = instance()
            it.pump = instance()
        }
    ) { CoffeeMaker() }
}

class MyActivity : Activity() {
    // eager injection of a non-optional dependency
    private val api: GitHubApi by inject()
    // eager injection of an optional dependency
    private val api: GitHubApi? by injectOrNull()
    // lazy injection of a non-optional dependency
    private val api: GitHubApi by injectLazy()
    // lazy injection of an optional dependency
    private val api: GitHubApi? by injectLazyOrNull()

    override fun onCreate(savedInstanceState: Bundle?) {
      // ... create or get the dependency graph
      Winter.inject(this)
      super.onCreate(savedInstanceState)
    }
}

// Extend the subgraph with subcomponent qualifier PresentationScope::class
@get:Rule
val winterRule = WinterRule {
    extend(PresentationScope::class) { // the component qualifier of the component we want to extend
        singleton<Dependency>(override = true) { TestDependency() }
    }

    testGraph(ApplicationScope::class) // the component qualifier of the graph we want to use
}

@Inject lateinit var classUnderTest: MyClassUnderTest

// Extend subgraph with subcomponent qualifier "presentation"
@JvmField
@RegisterExtension
val winterExtension = WinterEachExtension {
    extend(ApplicationScope::class) {
        singleton<Dependency>(override = true) {  TestDependency() }
    }
}

@Inject lateinit var classUnderTest: MyClassUnderTest

@BeforeEach
fun beforeEach() {
    Winter.openGraph()
}

// JUnit5 also offers a ParameterResolver feature that we support to resolve dependencies from
// the test graph
fun my_test_method(@WInject dependency: Dependency) {
    // do something with dependency
}

@get:Rule
val mockitoRule = MockitoJUnit.rule()

@get:Rule
val winterRule = WinterRule {
    // provide all mocks declared in MyTest in the application graph
    bindAllMocks()
}

@Mock lateinit var dependency1: MyDependency1

@Mock lateinit var dependency2: MyDependency2

@Inject lateinit var classUnderTest: MyClassUnderTest

@Before
fun beforeEach() {
    // create application object graph
    Winter.openGraph()
}

dependencies {
    kapt 'io.jentz.winter:winter-compiler:x.x.x'
}

package my.project.root.package.name.scope

import javax.inject.Scope

@Scope
@Retention
annotation class MyCustoScope

@ApplicationScope
@InjectConstuctor
class Pump

@ApplicationScope
@InjectConstuctor
class Heater

@ApplicationScope
@InjectConstuctor
class CoffeeMaker(val pump: Pump, val heater: Heater)

Winter.component {
    generated<Pump>()
    generated<Heater>()
    generated<CoffeeMaker>()
}
val coffeeMaker: CoffeeMakter = Winter.openGraph().instance()

class Parent(val child: Child)
class Child {
    lateinit var parent: Parent
}

val applicationComponent = component {
    singleton { Parent(instance()) }
    singleton(postConstruct = { it.parent = instance() }) { Child() }
}