Merge pull request #5 from apatrida/master

Move to latest 1.1-M04 and kotlin-script-util to lower code in this kernel

Author: ligee

build.gradle

@@ -1,7 +1,7 @@
 
 buildscript {
     ext.shadowJarVersion = "1.2.3"
-    ext.kotlinVersion = '1.1.0-dev-1920'
+    ext.kotlinVersion = '1.1-M04'
     repositories {
         maven { url 'https://dl.bintray.com/kotlin/kotlin-dev' }
         maven { url 'https://repo.gradle.org/gradle/repo' }
@@ -43,6 +43,7 @@ configurations {
 dependencies {
     compile project(':jupyter-lib')
     compile "org.jetbrains.kotlin:kotlin-compiler-embeddable:$kotlinVersion"
+    compile "org.jetbrains.kotlin:kotlin-script-util:$kotlinVersion"
     compile 'org.slf4j:slf4j-api:1.7.21'
     compile 'org.zeromq:jeromq:0.3.5'
     compile 'com.beust:klaxon:0.24'

jupyter-lib/src/main/kotlin/jupyter/kotlin/dependencies.kt

@@ -2,19 +2,65 @@ package org.jetbrains.kotlin.jupyter
 
 import jupyter.kotlin.Result
 import jupyter.kotlin.textResult
+import org.jetbrains.kotlin.cli.common.repl.ReplEvalResult
+import java.io.ByteArrayOutputStream
+import java.io.OutputStream
+import java.io.PrintStream
 
-val ReplForJupyter.EvalResult.asResult: Result get() = when (this) {
-    is ReplForJupyter.EvalResult.ValueResult -> {
-        if (value is Result) value
+val ReplEvalResult.asResult: Result get() = when (this) {
+    is ReplEvalResult.ValueResult -> {
+        if (value is Result) value as Result
         else textResult(
                 try {
                     value.toString()
                 } catch (e: Exception) {
                     "Unable to convert result to string: $e"
                 })
     }
-    is ReplForJupyter.EvalResult.UnitResult -> textResult("Ok")
-    is ReplForJupyter.EvalResult.Error -> textResult(errorText)
-    is ReplForJupyter.EvalResult.Incomplete -> textResult("error: incomplete code")
+    is ReplEvalResult.UnitResult -> textResult("Ok")
+    is ReplEvalResult.Error -> textResult(message)
+    is ReplEvalResult.Incomplete -> textResult("error: incomplete code")
     else -> throw Exception("Unexpected result from eval call: $this")
 }
+
+class ForkingOutputStream(val stdout: PrintStream, val publish: PrintStream, val captureOutput: Boolean) : OutputStream() {
+    val capturedOutput = ByteArrayOutputStream()
+
+    override fun write(b: Int) {
+        stdout.write(b)
+        publish.write(b)
+        if (captureOutput) capturedOutput.write(b)
+    }
+}
+
+fun JupyterConnection.evalWithIO(body: () -> ReplEvalResult): ReplEvalResult {
+    val out = System.out
+    val err = System.err
+
+    // TODO: make configuration option of whether to pipe back stdout and stderr
+    // TODO: make a configuration option to limit the total stdout / stderr possibly returned (in case it goes wild...)
+    val forkedOut = ForkingOutputStream(out, iopubOut, true)
+    val forkedError = ForkingOutputStream(err, iopubErr, false)
+
+    System.setOut(PrintStream(forkedOut, true, "UTF-8"))
+    System.setErr(PrintStream(forkedError, true, "UTF-8"))
+
+    val `in` = System.`in`
+    System.setIn(stdinIn)
+    try {
+        return body().let {
+            // TODO: make this a configuration option to pass back the stdout as the value if Unit (notebooks do not display the stdout, only console does)
+            if (it is ReplEvalResult.UnitResult) {
+                ReplEvalResult.ValueResult(it.updatedHistory, String(forkedOut.capturedOutput.toByteArray()))
+            } else {
+                it
+            }
+        }
+
+    }
+    finally {
+        System.setIn(`in`)
+        System.setErr(err)
+        System.setOut(out)
+    }
+}

jupyter-lib/src/main/kotlin/jupyter/kotlin/script.kt

@@ -5,7 +5,9 @@ import com.beust.klaxon.JsonObject
 import com.beust.klaxon.Parser
 import com.beust.klaxon.int
 import com.beust.klaxon.string
-import org.jetbrains.kotlin.cli.common.KotlinVersion
+import org.jetbrains.kotlin.cli.common.repl.ReplCheckResult
+import org.jetbrains.kotlin.cli.common.repl.ReplEvalResult
+import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import java.io.File
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.concurrent.thread
@@ -111,7 +113,7 @@ fun JupyterConnection.Socket.shellMessagesHandler(msg: Message, repl: ReplForJup
                     content = jsonObject(
                             "protocol_version" to protocolVersion,
                             "language" to "Kotlin",
-                            "language_version" to KotlinVersion.VERSION,
+                            "language_version" to KotlinCompilerVersion.VERSION,
                             "language_info" to jsonObject("name" to "kotlin", "file_extension" to "kt")
                     )))
         "history_request" ->
@@ -126,7 +128,7 @@ fun JupyterConnection.Socket.shellMessagesHandler(msg: Message, repl: ReplForJup
         "connect_request" ->
             send(makeReplyMessage(msg, "connection_reply",
                     content = jsonObject(JupyterSockets.values()
-                                            .map { Pair("${it.name}_port", connection.config.ports[it.ordinal]) })))
+                            .map { Pair("${it.name}_port", connection.config.ports[it.ordinal]) })))
         "execute_request" -> {
             connection.contextMessage = msg
             val count = executionCount.getAndIncrement()
@@ -138,7 +140,7 @@ fun JupyterConnection.Socket.shellMessagesHandler(msg: Message, repl: ReplForJup
                         "execution_count" to count,
                         "code" to code)))
                 val res = if (isCommand(code.toString())) runCommand(code.toString(), repl)
-                          else (repl?.eval(count, code.toString()) ?: ReplForJupyter.EvalResult.Error.Runtime("no repl!")).asResult
+                else (connection.evalWithIO { repl?.eval(count, code.toString()) ?: ReplEvalResult.Error.Runtime(emptyList(), "no repl!") }).asResult
                 send(makeReplyMessage(msg, "execute_result", content = jsonObject(
                         "execution_count" to count,
                         "data" to res,
@@ -157,17 +159,17 @@ fun JupyterConnection.Socket.shellMessagesHandler(msg: Message, repl: ReplForJup
                             "user_variables" to JsonObject(),
                             "payload" to listOf<String>(),
                             "user_expressions" to JsonObject())
-                    ))
+            ))
             connection.contextMessage = null
         }
         "is_complete_request" -> {
             val code = msg.content["code"].toString()
             val resStr = if (isCommand(code)) "complete" else {
                 val res = repl?.checkComplete(executionCount.get(), code)
                 when (res) {
-                    is ReplForJupyter.EvalResult.Error -> "invalid"
-                    is ReplForJupyter.EvalResult.Incomplete -> "incomplete"
-                    is ReplForJupyter.EvalResult.Ready -> "complete"
+                    is ReplCheckResult.Error -> "invalid"
+                    is ReplCheckResult.Incomplete -> "incomplete"
+                    is ReplCheckResult.Ok -> "complete"
                     null -> "error: no repl"
                     else -> throw Exception("unexpected result from checkComplete call: $res")
                 }