Update to latest Ratpack and Kotlin

Author: robfletcher

annotations/ratpack/ratpack/handling/annotations.xml

@@ -3,28 +3,50 @@ buildscript {
     jcenter()
   }
   dependencies {
-    classpath "io.ratpack:ratpack-gradle:0.9.7"
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:0.8.11"
+    classpath "io.ratpack:ratpack-gradle:0.9.13",
+        "com.github.jengelman.gradle.plugins:shadow:1.2.1",
+        "org.jetbrains.kotlin:kotlin-gradle-plugin:0.10.770"
   }
 }
 
+if (!JavaVersion.current().java8Compatible) {
+  throw new IllegalStateException("Must be built with Java 8 or higher")
+}
+
 apply plugin: "io.ratpack.ratpack-java"
+apply plugin: "com.github.johnrengelman.shadow"
 apply plugin: "kotlin"
 
 repositories {
-  maven { url "http://oss.jfrog.org/artifactory/repo" }
+  maven { url "http://clinker.netty.io/nexus/content/repositories/snapshots" }
   jcenter()
 }
 
 dependencies {
-  compile "org.jetbrains.kotlin:kotlin-stdlib:0.8.11"
+  compile "org.jetbrains.kotlin:kotlin-stdlib:0.10.770"
   compile ratpack.dependency("guice")
-  testCompile "junit:junit:4.11"
-  springloaded "org.springframework:springloaded:1.2.0.RELEASE"
+  testCompile "junit:junit:4.12"
 }
 
 compileKotlin {
   kotlinOptions.annotations = file("annotations/ratpack")
 }
 
-apply plugin: "idea"
+apply plugin: "idea"
+
+idea {
+  project {
+    //use JDK 1.8 in idea
+    jdkName "1.8"
+    languageLevel "1.8"
+    ipr {
+      withXml { provider ->
+        def node = provider.asNode()
+        //configure git support for the project in idea
+        node.component.find { it.'@name' == 'VcsDirectoryMappings' }?.mapping[0].'@vcs' = 'Git'
+      }
+    }
+  }
+}
+
+mainClassName = "ratpack.example.kotlin.KotlinPackage"

build.gradle

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.0-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-all.zip

gradle/wrapper/gradle-wrapper.properties

@@ -1,66 +1,37 @@
 package ratpack.example.kotlin
 
-import ratpack.launch.LaunchConfig
-import ratpack.handling.Handler
-import ratpack.guice.Guice.handler
-import ratpack.handling.ChainAction
-import ratpack.handling.Chain
-import ratpack.func.Action
-import ratpack.guice.BindingsSpec
+import ratpack.registry.Registry
+import ratpack.guice.Guice
 
 class HandlerFactory : ratpack.launch.HandlerFactory {
-  override fun create(launchConfig : LaunchConfig?) = handler(launchConfig!!, registerModules, routes)
-
-  /**
-   * Registers all of the Guice modules that make up the application.
-   *
-   * This is only invoked once during application bootstrap. If you change the
-   * module configuration of an application, you must restart it.
-   */
-  private val registerModules = Action {(registry : BindingsSpec?) ->
-    registry!!.add(MyModule())
-  }
-
-  private val routes = Action {(chain : Chain?) ->
-    Routes().execute(chain!!)
-  }
-
-  private class Routes : ChainAction() {
-    /**
-     * Adds potential routes.
-     *
-     * After this method completes, a handler chain will be constructed from
-     * the specified routes.
-     *
-     * This method will be called for every request. This makes it possible
-     * to dynamically define the routes if necessary.
-     */
-    override fun execute() {
-      // Map to /foo
-      handler("foo") { context -> context.render("from the foo handler") }
-
-      // Map to /bar
-      handler("bar") { context -> context.render("from the bar handler") }
-
-      // Set up a nested routing block, which is delegated to `nestedHandler`
-      prefix("nested") {(nested : Chain?) ->
-        // Map to /nested/*/*
-        nested!!.handler(":var1/:var2?") { context ->
-          // The path tokens are the :var1 and :var2 path components above
-          val pathTokens = context.getPathTokens()!!
-          context.render("from the nested handler, var1: ${pathTokens["var1"]}, var2: ${pathTokens["var2"]}")
-        }
-      }
-
-      // Map to a dependency injected handler
-      handler("injected", getRegistry()!![javaClass<MyHandler>()])
-
-      // Bind the /static app path to the src/ratpack/assets/images dir
-      // Try /static/logo.png
-      prefix("static") {(nested : Chain?) -> nested!!.assets("assets/images") }
-
-      // If nothing above matched, we'll get to here.
-      handler { context -> context.render("root handler!") }
-    }
-  }
+  override fun create(registry : Registry) = Guice.builder(registry)
+      .bindings({ registry -> registry.add(MyModule()) })
+      .build({ chain ->
+        chain
+            // Map to /foo
+            .handler("foo") { context -> context.render("from the foo handler") }
+
+            // Map to /bar
+            .handler("bar") { context -> context.render("from the bar handler") }
+
+            // Set up a nested routing block, which is delegated to `nestedHandler`
+            .prefix("nested") { nested ->
+              // Map to /nested/*/*
+              nested.handler(":var1/:var2?") { context ->
+                // The path tokens are the :var1 and :var2 path components above
+                val pathTokens = context.getPathTokens()
+                context.render("from the nested handler, var1: ${pathTokens["var1"]}, var2: ${pathTokens["var2"]}")
+              }
+            }
+
+            // Map to a dependency injected handler
+            .handler("injected", chain.getRegistry()[javaClass<MyHandler>()])
+
+            // Bind the /static app path to the src/ratpack/assets/images dir
+            // Try /static/logo.png
+            .prefix("static") { nested -> nested.assets("assets/images") }
+
+            // If nothing above matched, we'll get to here.
+            .handler { context -> context.render("root handler!") }
+      })
 }

src/main/kotlin/ratpack/example/kotlin/HandlerFactory.kt

@@ -0,0 +1,13 @@
+package ratpack.example.kotlin
+
+import ratpack.server.RatpackServer
+import ratpack.server.ServerConfig
+
+fun main(args : Array<String>) {
+  RatpackServer.of({ b ->
+    b.serverConfig(ServerConfig.findBaseDirProps())
+    b.handler({ registry ->
+      HandlerFactory().create(registry)
+    })
+  }).start()
+}

src/main/kotlin/ratpack/example/kotlin/MyApp.kt

@@ -13,6 +13,6 @@ import javax.inject.Inject
  */
 Singleton class MyHandler [Inject] (private val myService : MyService) : Handler {
   override fun handle(context : Context) {
-    context.getResponse()!!.send("service value: ${myService.getValue()}")
+    context.getResponse().send("service value: ${myService.getValue()}")
   }
 }

src/main/kotlin/ratpack/example/kotlin/MyHandler.kt

@@ -17,7 +17,7 @@ class MyModule : AbstractModule(), HandlerDecoratingModule {
    * @see MyHandler
    */
   protected override fun configure() {
-    bind(javaClass<MyService>())!!.to(javaClass<MyServiceImpl>())
+    bind(javaClass<MyService>()).to(javaClass<MyServiceImpl>())
   }
 
   /**
@@ -30,4 +30,4 @@ class MyModule : AbstractModule(), HandlerDecoratingModule {
   override fun decorate(injector : Injector?, handler : Handler?) = chain(LoggingHandler(), handler)
 }
 
-fun AbstractModule.chain(vararg handlers : Handler) = chain(handlers.toList())!!
+fun AbstractModule.chain(vararg handlers : Handler) = chain(handlers.toList())

src/main/kotlin/ratpack/example/kotlin/MyModule.kt

@@ -0,0 +1,16 @@
+package ratpack.example.kotlin
+
+import ratpack.test.ServerBackedApplicationUnderTest
+import ratpack.server.RatpackServer
+import ratpack.server.internal.ServerCapturer
+import ratpack.registry.Registries
+import ratpack.registry.Registry
+import kotlin.reflect.KFunction1
+
+class KotlinApplicationUnderTest(private val mainFun : KFunction1<Array<String>, Unit>) : ServerBackedApplicationUnderTest() {
+  protected fun createOverrides(serverRegistry : Registry) : Registry = Registries.empty()
+
+  override fun createServer() : RatpackServer = ServerCapturer.capture(ServerCapturer.Overrides().port(0).development(true).registry { registry -> createOverrides(registry) }, {
+    mainFun(array<String>())
+  }).orElseThrow { -> IllegalStateException("${mainFun.javaClass}.main() did not start a Ratpack server") }
+}

src/test/kotlin/ratpack/example/kotlin/KotlinApplicationUnderTest.kt

@@ -5,14 +5,13 @@ import java.io.InputStreamReader
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
-import ratpack.test.RatpackMainApplicationUnderTest
 import kotlin.test.assertEquals
 import kotlin.test.fail
 
 [RunWith(javaClass<JUnit4>())]
 class SiteTest {
 
-  val aut = RatpackMainApplicationUnderTest()
+  val aut = KotlinApplicationUnderTest(::main)
 
   Test fun fooHandler() {
     assertEquals("from the foo handler", get("/foo"))
@@ -41,12 +40,12 @@ class SiteTest {
   }
 
   private fun get(path : String) : String {
-    val uri = aut.getAddress()!!.resolve(path)
+    val uri = aut.getAddress().resolve(path)
     val stream = uri.toURL().openStream()
     try {
-      val reader = InputStreamReader(stream!!)
+      val reader = InputStreamReader(stream)
       try {
-        return CharStreams.toString(reader)!!
+        return CharStreams.toString(reader)
       } finally {
         reader.close()
       }