Continue to expand the Module API exposed

Author: JLLeitschuh

core/src/main/kotlin/org/jlleitschuh/guice/BinderScope.kt

@@ -3,12 +3,11 @@ package org.jlleitschuh.guice
 import com.google.inject.Binder
 import com.google.inject.Key
 import com.google.inject.TypeLiteral
-import com.google.inject.binder.AnnotatedBindingBuilder
 import org.jlleitschuh.guice.binder.AnnotatedBindingBuilderScope
 import org.jlleitschuh.guice.binder.LinkedBindingBuilderScope
 import kotlin.reflect.KClass
 
-class BinderScope
+open class BinderScope
 internal constructor(private val binder: Binder) : Binder by binder {
 
     /**
@@ -25,7 +24,7 @@ internal constructor(private val binder: Binder) : Binder by binder {
     /**
      * See the EDSL examples at [Binder].
      */
-    override fun <T : Any> bind(key: Key<T>) =
+    override fun <T : Any> bind(key: Key<T>): LinkedBindingBuilderScope<T> =
         LinkedBindingBuilderScope(binder.bind(key))
 
     /**
@@ -40,4 +39,8 @@ internal constructor(private val binder: Binder) : Binder by binder {
     override fun <T : Any> bind(typeLiteral: TypeLiteral<T>): AnnotatedBindingBuilderScope<T> =
         AnnotatedBindingBuilderScope(binder.bind(typeLiteral))
 
+
+    override fun newPrivateBinder(): PrivateBinderScope =
+        PrivateBinderScope(binder.newPrivateBinder())
+
 }

core/src/main/kotlin/org/jlleitschuh/guice/Module.kt

@@ -1,10 +1,23 @@
 package org.jlleitschuh.guice
 
 import com.google.inject.Module
+import com.google.inject.PrivateModule
 
 /**
  * Creates a [Module] with the [BinderScope] being configured when [Module.configure]
  * is called by Guice.
  */
 fun module(configure: BinderScope.() -> Unit) =
-    Module { binder -> BinderScope(binder).configure() }
+    Module { binder -> BinderScope(binder).configure() }
+
+/**
+ * Creates a [PrivateModule] with the [PrivateBinderScope] being configured when [PrivateModule.configure]
+ * is called by Guice.
+ */
+fun privateModule(configure: PrivateBinderScope.() -> Unit) =
+    // The PrivateModule data type has some reflection checks to get the right type passed in. Easier to just use it.
+    object : PrivateModule() {
+        override fun configure() =
+            configure.invoke(PrivateBinderScope(binder()))
+
+    }

core/src/main/kotlin/org/jlleitschuh/guice/PrivateBinderScope.kt

@@ -0,0 +1,30 @@
+package org.jlleitschuh.guice
+
+import com.google.inject.Key
+import com.google.inject.PrivateBinder
+import com.google.inject.TypeLiteral
+import com.google.inject.binder.AnnotatedElementBuilder
+
+class PrivateBinderScope
+internal constructor(private val privateBinder: PrivateBinder): BinderScope(privateBinder), PrivateBinder {
+
+    override fun skipSources(vararg classesToSkip: Class<*>): PrivateBinderScope {
+        return PrivateBinderScope(privateBinder.skipSources(*classesToSkip))
+    }
+
+    override fun withSource(source: Any): PrivateBinder {
+        return PrivateBinderScope(privateBinder.withSource(source))
+    }
+
+    override fun expose(key: Key<*>) {
+        privateBinder.expose(key)
+    }
+
+    override fun expose(type: Class<*>): AnnotatedElementBuilder {
+        return privateBinder.expose(type)
+    }
+
+    override fun expose(type: TypeLiteral<*>): AnnotatedElementBuilder {
+        return privateBinder.expose(type)
+    }
+}

core/src/main/kotlin/org/jlleitschuh/guice/binder/AnnotatedBindingBuilderScope.kt

@@ -12,19 +12,19 @@ class AnnotatedBindingBuilderScope<T : Any>(
     /**
      * See the EDSL examples at [com.google.inject.Binder].
      */
-    fun annotatedWith(annotationType: KClass<out Annotation>): LinkedBindingBuilder<T> =
+    fun annotatedWith(annotationType: KClass<out Annotation>): LinkedBindingBuilderScope<T> =
         annotatedWith(annotationType.java)
 
     /**
      * See the EDSL examples at [com.google.inject.Binder].
      */
-    override fun annotatedWith(annotationType: Class<out Annotation>): LinkedBindingBuilder<T> =
+    override fun annotatedWith(annotationType: Class<out Annotation>): LinkedBindingBuilderScope<T> =
         LinkedBindingBuilderScope(annotatedBindingBuilder.annotatedWith(annotationType))
 
     /**
      * See the EDSL examples at [com.google.inject.Binder].
      */
-    override fun annotatedWith(annotation: Annotation): LinkedBindingBuilder<T> =
+    override fun annotatedWith(annotation: Annotation): LinkedBindingBuilderScope<T> =
         LinkedBindingBuilderScope(annotatedBindingBuilder.annotatedWith(annotation))
 
 }

core/src/main/kotlin/org/jlleitschuh/guice/binder/LinkedBindingBuilderScope.kt

@@ -18,7 +18,7 @@ open class LinkedBindingBuilderScope<T : Any>(
      * See the EDSL examples at [com.google.inject.Binder].
      */
     fun to(implementation: KClass<out T>): ScopedBindingBuilderScope =
-        ScopedBindingBuilderScope(to(implementation.java))
+        to(implementation.java)
 
     /**
      * See the EDSL examples at [com.google.inject.Binder].