Refactor rendering API

ileasile · ileasile · commit 71853eb347a5 · 2021-05-23T23:13:33.000+03:00
diff --git a/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/Notebook.kt b/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/Notebook.kt
@@ -68,5 +68,5 @@ interface Notebook {
      * Renderers processor gives an ability to render values and
      * and add new renderers
      */
-    val renderersProcessor: TypeRenderersProcessor
+    val renderersProcessor: RenderersProcessor
 }
diff --git a/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/RenderersProcessor.kt b/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/RenderersProcessor.kt
@@ -3,11 +3,11 @@ package org.jetbrains.kotlinx.jupyter.api
 import org.jetbrains.kotlinx.jupyter.api.libraries.ExecutionHost
 
 /**
- * [TypeRenderersProcessor] is responsible for rendering objects.
+ * [RenderersProcessor] is responsible for rendering objects.
  * You may use it to render values exactly like notebook renders results,
  * and also register new renderers in runtime.
  */
-interface TypeRenderersProcessor {
+interface RenderersProcessor {
     /**
      * Renders [value] in context of this execution [host]
      */
@@ -17,5 +17,5 @@ interface TypeRenderersProcessor {
      * Adds new [renderer] for this notebook.
      * Don't turn on the optimizations for [PrecompiledRendererTypeHandler]
      */
-    fun registerWithoutOptimizing(renderer: RendererTypeHandler)
+    fun registerWithoutOptimizing(renderer: RendererHandler)
 }
diff --git a/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/JupyterIntegration.kt b/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/JupyterIntegration.kt
@@ -15,6 +15,7 @@ import org.jetbrains.kotlinx.jupyter.api.FileAnnotationCallback
 import org.jetbrains.kotlinx.jupyter.api.FileAnnotationHandler
 import org.jetbrains.kotlinx.jupyter.api.KotlinKernelHost
 import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.RendererHandler
 import org.jetbrains.kotlinx.jupyter.api.RendererTypeHandler
 import org.jetbrains.kotlinx.jupyter.api.ResultHandlerExecution
 import org.jetbrains.kotlinx.jupyter.api.SubtypeRendererTypeHandler
@@ -32,7 +33,7 @@ abstract class JupyterIntegration : LibraryDefinitionProducer {
 
     class Builder(val notebook: Notebook) {
 
-        private val renderers = mutableListOf<RendererTypeHandler>()
+        private val renderers = mutableListOf<RendererHandler>()
 
         private val init = mutableListOf<ExecutionCallback<*>>()
 
@@ -58,6 +59,11 @@ abstract class JupyterIntegration : LibraryDefinitionProducer {
 
         private val codePreprocessors = mutableListOf<CodePreprocessor>()
 
+        fun addRenderer(handler: RendererHandler) {
+            renderers.add(handler)
+        }
+
+        // Left for ABI compatibility
         fun addRenderer(handler: RendererTypeHandler) {
             renderers.add(handler)
         }
diff --git a/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/LibraryDefinition.kt b/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/LibraryDefinition.kt
@@ -7,7 +7,7 @@ import org.jetbrains.kotlinx.jupyter.api.ExecutionCallback
 import org.jetbrains.kotlinx.jupyter.api.FieldHandler
 import org.jetbrains.kotlinx.jupyter.api.FileAnnotationHandler
 import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
-import org.jetbrains.kotlinx.jupyter.api.RendererTypeHandler
+import org.jetbrains.kotlinx.jupyter.api.RendererHandler
 
 /**
  * Library definition represents "library" concept in Kotlin kernel.
@@ -59,7 +59,7 @@ interface LibraryDefinition {
      * List of type renderers. Consider using [org.jetbrains.kotlinx.jupyter.api.Renderable]
      * as it's generally more convenient
      */
-    val renderers: List<RendererTypeHandler>
+    val renderers: List<RendererHandler>
         get() = emptyList()
 
     /**
diff --git a/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/LibraryDefinitionImpl.kt b/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/LibraryDefinitionImpl.kt
@@ -7,7 +7,7 @@ import org.jetbrains.kotlinx.jupyter.api.ExecutionCallback
 import org.jetbrains.kotlinx.jupyter.api.FieldHandler
 import org.jetbrains.kotlinx.jupyter.api.FileAnnotationHandler
 import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
-import org.jetbrains.kotlinx.jupyter.api.RendererTypeHandler
+import org.jetbrains.kotlinx.jupyter.api.RendererHandler
 
 /**
  * Trivial implementation of [LibraryDefinition] - simple container.
@@ -20,7 +20,7 @@ class LibraryDefinitionImpl private constructor() : LibraryDefinition {
     override var initCell: List<ExecutionCallback<*>> = emptyList()
     override var afterCellExecution: List<AfterCellExecutionCallback> = emptyList()
     override var shutdown: List<ExecutionCallback<*>> = emptyList()
-    override var renderers: List<RendererTypeHandler> = emptyList()
+    override var renderers: List<RendererHandler> = emptyList()
     override var converters: List<FieldHandler> = emptyList()
     override var classAnnotations: List<ClassAnnotationHandler> = emptyList()
     override var fileAnnotations: List<FileAnnotationHandler> = emptyList()
diff --git a/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/renderersHandling.kt b/jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/renderersHandling.kt
@@ -37,21 +37,32 @@ class ResultHandlerCodeExecution(val code: Code) : ResultHandlerExecution {
 }
 
 /**
- * Type handler for result renderers
+ * [RendererHandler] renders results for which [accepts] returns `true`
  */
-interface RendererTypeHandler : VariablesSubstitutionAware<RendererTypeHandler> {
+interface RendererHandler : VariablesSubstitutionAware<RendererHandler> {
     /**
-     * Returns true if this renderer accepts [type], false otherwise
+     * Returns true if this renderer accepts [value], false otherwise
      */
-    fun acceptsType(type: KClass<*>): Boolean
+    fun accepts(value: Any?): Boolean
 
     /**
      * Execution to handle result.
-     * Should not throw if [acceptsType] returns true
+     * Should not throw if [accepts] returns true
      */
     val execution: ResultHandlerExecution
 }
 
+/**
+ * [RendererTypeHandler] handles results for which runtime types [acceptsType] returns `true`
+ */
+interface RendererTypeHandler : RendererHandler {
+    fun acceptsType(type: KClass<*>): Boolean
+
+    override fun accepts(value: Any?): Boolean {
+        return if (value == null) false else acceptsType(value::class)
+    }
+}
+
 /**
  * Precompiled renderer type handler. Override this interface if
  * you want type rendering to be optimized.
diff --git a/jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/codegen/ResultsRenderersProcessor.kt b/jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/codegen/ResultsRenderersProcessor.kt
@@ -3,11 +3,11 @@ package org.jetbrains.kotlinx.jupyter.codegen
 import org.jetbrains.kotlinx.jupyter.api.Code
 import org.jetbrains.kotlinx.jupyter.api.FieldValue
 import org.jetbrains.kotlinx.jupyter.api.PrecompiledRendererTypeHandler
-import org.jetbrains.kotlinx.jupyter.api.RendererTypeHandler
-import org.jetbrains.kotlinx.jupyter.api.TypeRenderersProcessor
+import org.jetbrains.kotlinx.jupyter.api.RendererHandler
+import org.jetbrains.kotlinx.jupyter.api.RenderersProcessor
 import org.jetbrains.kotlinx.jupyter.api.libraries.ExecutionHost
 
-interface ResultsTypeRenderersProcessor : TypeRenderersProcessor {
+interface ResultsRenderersProcessor : RenderersProcessor {
     /**
      * Renders cell result [field] represented as [FieldValue] in the [host] context
      */
@@ -18,5 +18,5 @@ interface ResultsTypeRenderersProcessor : TypeRenderersProcessor {
      * Returns code to be executed on execution host
      * for [PrecompiledRendererTypeHandler]'s.
      */
-    fun register(renderer: RendererTypeHandler): Code?
+    fun register(renderer: RendererHandler): Code?
 }
diff --git a/src/main/kotlin/org/jetbrains/kotlinx/jupyter/apiImpl.kt b/src/main/kotlin/org/jetbrains/kotlinx/jupyter/apiImpl.kt
@@ -8,7 +8,7 @@ import org.jetbrains.kotlinx.jupyter.api.DisplayResultWithCell
 import org.jetbrains.kotlinx.jupyter.api.JREInfoProvider
 import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
 import org.jetbrains.kotlinx.jupyter.api.Notebook
-import org.jetbrains.kotlinx.jupyter.api.TypeRenderersProcessor
+import org.jetbrains.kotlinx.jupyter.api.RenderersProcessor
 import java.lang.IllegalStateException
 
 class DisplayResultWrapper private constructor(
@@ -99,7 +99,7 @@ class NotebookImpl(
     private val runtimeProperties: ReplRuntimeProperties,
 ) : Notebook {
     private val cells = hashMapOf<Int, CodeCellImpl>()
-    internal var typeRenderersProcessor: TypeRenderersProcessor? = null
+    internal var typeRenderersProcessor: RenderersProcessor? = null
 
     override val cellsList: Collection<CodeCellImpl>
         get() = cells.values
@@ -159,6 +159,6 @@ class NotebookImpl(
     override val lastCell: CodeCellImpl?
         get() = history(1)
 
-    override val renderersProcessor: TypeRenderersProcessor
+    override val renderersProcessor: RenderersProcessor
         get() = typeRenderersProcessor ?: throw IllegalStateException("Type renderers processor is not initialized yet")
 }
diff --git a/src/main/kotlin/org/jetbrains/kotlinx/jupyter/codegen/RenderersProcessorImpl.kt b/src/main/kotlin/org/jetbrains/kotlinx/jupyter/codegen/RenderersProcessorImpl.kt
@@ -3,21 +3,21 @@ package org.jetbrains.kotlinx.jupyter.codegen
 import org.jetbrains.kotlinx.jupyter.api.Code
 import org.jetbrains.kotlinx.jupyter.api.FieldValue
 import org.jetbrains.kotlinx.jupyter.api.PrecompiledRendererTypeHandler
-import org.jetbrains.kotlinx.jupyter.api.RendererTypeHandler
+import org.jetbrains.kotlinx.jupyter.api.RendererHandler
 import org.jetbrains.kotlinx.jupyter.api.libraries.ExecutionHost
 import org.jetbrains.kotlinx.jupyter.exceptions.LibraryProblemPart
 import org.jetbrains.kotlinx.jupyter.exceptions.rethrowAsLibraryException
 import org.jetbrains.kotlinx.jupyter.repl.ContextUpdater
 
-class TypeRenderersProcessorImpl(
+class RenderersProcessorImpl(
     private val contextUpdater: ContextUpdater,
-) : ResultsTypeRenderersProcessor {
+) : ResultsRenderersProcessor {
     private var counter = 0
-    private val typeRenderers: MutableList<HandlerWithInfo> = mutableListOf()
+    private val renderers: MutableList<HandlerWithInfo> = mutableListOf()
 
     override tailrec fun renderResult(host: ExecutionHost, field: FieldValue): Any? {
-        val value = field.value ?: return null
-        val (handler, id) = typeRenderers.firstOrNull { it.handler.acceptsType(value::class) }
+        val value = field.value
+        val (handler, id) = renderers.firstOrNull { it.handler.accepts(value) }
             ?: return value
         return if (id == null) {
             val newField = rethrowAsLibraryException(LibraryProblemPart.RENDERERS) {
@@ -39,30 +39,30 @@ class TypeRenderersProcessorImpl(
         return renderResult(host, FieldValue(value, null))
     }
 
-    override fun register(renderer: RendererTypeHandler): Code? {
+    override fun register(renderer: RendererHandler): Code? {
         return register(renderer, true)
     }
 
-    override fun registerWithoutOptimizing(renderer: RendererTypeHandler) {
+    override fun registerWithoutOptimizing(renderer: RendererHandler) {
         register(renderer, false)
     }
 
-    private fun register(renderer: RendererTypeHandler, doOptimization: Boolean): Code? {
+    private fun register(renderer: RendererHandler, doOptimization: Boolean): Code? {
         if (!doOptimization || renderer !is PrecompiledRendererTypeHandler || !renderer.mayBePrecompiled) {
-            typeRenderers.add(HandlerWithInfo(renderer, null))
+            renderers.add(HandlerWithInfo(renderer, null))
             return null
         }
 
         val id = counter++
-        typeRenderers.add(HandlerWithInfo(renderer, id))
+        renderers.add(HandlerWithInfo(renderer, id))
         val methodName = getMethodName(id)
         return renderer.precompile(methodName, "___value")
     }
 
     private fun getMethodName(id: Int) = "___renderResult$id"
 
     private data class HandlerWithInfo(
-        val handler: RendererTypeHandler,
+        val handler: RendererHandler,
         val id: Int?,
     )
 }
diff --git a/src/main/kotlin/org/jetbrains/kotlinx/jupyter/protocol.kt b/src/main/kotlin/org/jetbrains/kotlinx/jupyter/protocol.kt
@@ -411,7 +411,8 @@ class CapturingOutputStream(
     }
 }
 
-fun Any.toDisplayResult(notebook: Notebook): DisplayResult? = when (this) {
+fun Any?.toDisplayResult(notebook: Notebook): DisplayResult? = when (this) {
+    null -> textResult("null")
     is DisplayResult -> this
     is Renderable -> this.render(notebook)
     is Unit -> null
@@ -475,7 +476,7 @@ fun JupyterConnection.evalWithIO(repl: ReplForJupyter, srcMessage: Message, body
                 else -> {
                     flushStreams()
                     try {
-                        val result = exec.resultValue?.toDisplayResult(repl.notebook)
+                        val result = exec.resultValue.toDisplayResult(repl.notebook)
                         OkResponseWithMessage(result, exec.metadata)
                     } catch (e: Exception) {
                         AbortResponseWithMessage("error:  Unable to convert result to a string: $e")
diff --git a/src/main/kotlin/org/jetbrains/kotlinx/jupyter/repl.kt b/src/main/kotlin/org/jetbrains/kotlinx/jupyter/repl.kt
@@ -17,8 +17,8 @@ import org.jetbrains.kotlinx.jupyter.codegen.FieldsProcessor
 import org.jetbrains.kotlinx.jupyter.codegen.FieldsProcessorImpl
 import org.jetbrains.kotlinx.jupyter.codegen.FileAnnotationsProcessor
 import org.jetbrains.kotlinx.jupyter.codegen.FileAnnotationsProcessorImpl
-import org.jetbrains.kotlinx.jupyter.codegen.ResultsTypeRenderersProcessor
-import org.jetbrains.kotlinx.jupyter.codegen.TypeRenderersProcessorImpl
+import org.jetbrains.kotlinx.jupyter.codegen.ResultsRenderersProcessor
+import org.jetbrains.kotlinx.jupyter.codegen.RenderersProcessorImpl
 import org.jetbrains.kotlinx.jupyter.common.looksLikeReplCommand
 import org.jetbrains.kotlinx.jupyter.compiler.CompilerArgsConfigurator
 import org.jetbrains.kotlinx.jupyter.compiler.DefaultCompilerArgsConfigurator
@@ -311,8 +311,8 @@ class ReplForJupyterImpl(
         executedCodeLogging != ExecutedCodeLogging.Off
     )
 
-    private val typeRenderersProcessor: ResultsTypeRenderersProcessor = run {
-        val processor = TypeRenderersProcessorImpl(contextUpdater)
+    private val renderersProcessor: ResultsRenderersProcessor = run {
+        val processor = RenderersProcessorImpl(contextUpdater)
         notebook.typeRenderersProcessor = processor
         processor
     }
@@ -329,7 +329,7 @@ class ReplForJupyterImpl(
         classAnnotationsProcessor,
         fileAnnotationsProcessor,
         fieldsProcessor,
-        typeRenderersProcessor,
+        renderersProcessor,
         codePreprocessor,
         resourcesProcessor,
         librariesScanner,
@@ -382,7 +382,7 @@ class ReplForJupyterImpl(
 
             val rendered = result.result.let {
                 log.catchAll {
-                    typeRenderersProcessor.renderResult(executor, it)
+                    renderersProcessor.renderResult(executor, it)
                 }
             }?.let {
                 log.catchAll {
diff --git a/src/main/kotlin/org/jetbrains/kotlinx/jupyter/repl/impl/CellExecutorImpl.kt b/src/main/kotlin/org/jetbrains/kotlinx/jupyter/repl/impl/CellExecutorImpl.kt
@@ -56,7 +56,7 @@ internal class CellExecutorImpl(private val replContext: SharedReplContext) : Ce
             } else code
 
             if (preprocessedCode.isBlank()) {
-                return InternalEvalResult(FieldValue(null, null), Unit)
+                return InternalEvalResult(FieldValue(Unit, null), Unit)
             }
 
             val result = baseHost.withHost(context) {
@@ -123,7 +123,7 @@ internal class CellExecutorImpl(private val replContext: SharedReplContext) : Ce
             rethrowAsLibraryException(LibraryProblemPart.INIT) {
                 library.init.forEach(::runChild)
             }
-            library.renderers.mapNotNull(sharedContext.typeRenderersProcessor::register).joinToLines().let(::runChild)
+            library.renderers.mapNotNull(sharedContext.renderersProcessor::register).joinToLines().let(::runChild)
             library.converters.forEach(sharedContext.fieldsProcessor::register)
             library.classAnnotations.forEach(sharedContext.classAnnotationsProcessor::register)
             library.fileAnnotations.forEach(sharedContext.fileAnnotationsProcessor::register)
diff --git a/src/main/kotlin/org/jetbrains/kotlinx/jupyter/repl/impl/SharedReplContext.kt b/src/main/kotlin/org/jetbrains/kotlinx/jupyter/repl/impl/SharedReplContext.kt
@@ -6,7 +6,7 @@ import org.jetbrains.kotlinx.jupyter.api.Notebook
 import org.jetbrains.kotlinx.jupyter.codegen.ClassAnnotationsProcessor
 import org.jetbrains.kotlinx.jupyter.codegen.FieldsProcessor
 import org.jetbrains.kotlinx.jupyter.codegen.FileAnnotationsProcessor
-import org.jetbrains.kotlinx.jupyter.codegen.ResultsTypeRenderersProcessor
+import org.jetbrains.kotlinx.jupyter.codegen.ResultsRenderersProcessor
 import org.jetbrains.kotlinx.jupyter.libraries.LibrariesScanner
 import org.jetbrains.kotlinx.jupyter.libraries.LibraryResourcesProcessor
 import org.jetbrains.kotlinx.jupyter.magics.CompoundCodePreprocessor
@@ -16,7 +16,7 @@ internal data class SharedReplContext(
     val classAnnotationsProcessor: ClassAnnotationsProcessor,
     val fileAnnotationsProcessor: FileAnnotationsProcessor,
     val fieldsProcessor: FieldsProcessor,
-    val typeRenderersProcessor: ResultsTypeRenderersProcessor,
+    val renderersProcessor: ResultsRenderersProcessor,
     val codePreprocessor: CompoundCodePreprocessor,
     val resourcesProcessor: LibraryResourcesProcessor,
     val librariesScanner: LibrariesScanner,
diff --git a/src/test/kotlin/org/jetbrains/kotlinx/jupyter/test/repl/ReplWithStandardResolverTests.kt b/src/test/kotlin/org/jetbrains/kotlinx/jupyter/test/repl/ReplWithStandardResolverTests.kt
@@ -8,12 +8,12 @@ import org.jetbrains.kotlinx.jupyter.libraries.LibraryDescriptorExt
 import org.jetbrains.kotlinx.jupyter.libraries.LibraryResolutionInfo
 import org.jetbrains.kotlinx.jupyter.libraries.LocalSettingsPath
 import org.jetbrains.kotlinx.jupyter.test.TestDisplayHandler
+import org.jetbrains.kotlinx.jupyter.test.assertUnit
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.parallel.Execution
 import org.junit.jupiter.api.parallel.ExecutionMode
 import kotlin.test.assertEquals
-import kotlin.test.assertNull
 
 @Execution(ExecutionMode.SAME_THREAD)
 class ReplWithStandardResolverTests : AbstractSingleReplTest() {
@@ -90,7 +90,7 @@ class ReplWithStandardResolverTests : AbstractSingleReplTest() {
 
         val res3 = eval("%use lets-plot@$commit", handler)
         assertEquals(1, displays.count())
-        assertNull(res3.resultValue)
+        assertUnit(res3.resultValue)
         displays.clear()
 
         val res4 = eval(
diff --git a/src/test/kotlin/org/jetbrains/kotlinx/jupyter/test/repl/ReplWithTestResolverTests.kt b/src/test/kotlin/org/jetbrains/kotlinx/jupyter/test/repl/ReplWithTestResolverTests.kt
@@ -2,12 +2,12 @@ package org.jetbrains.kotlinx.jupyter.test.repl
 
 import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
 import org.jetbrains.kotlinx.jupyter.test.TestDisplayHandler
+import org.jetbrains.kotlinx.jupyter.test.assertUnit
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.parallel.Execution
 import org.junit.jupiter.api.parallel.ExecutionMode
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
-import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 @Execution(ExecutionMode.SAME_THREAD)
@@ -25,7 +25,7 @@ class ReplWithTestResolverTests : AbstractSingleReplTest() {
         val res1 = eval(code1, displayHandler)
         assertEquals(1, displays.count())
         displays.clear()
-        assertNull(res1.resultValue)
+        assertUnit(res1.resultValue)
         val res2 = eval(code2, displayHandler)
         assertEquals(0, displays.count())
         val mime = res2.resultValue as? MimeTypedResult
diff --git a/src/test/kotlin/org/jetbrains/kotlinx/jupyter/test/testUtil.kt b/src/test/kotlin/org/jetbrains/kotlinx/jupyter/test/testUtil.kt

Original file line number	Diff line number	Diff line change
`@@ -68,5 +68,5 @@ interface Notebook {`
`68`	`68`	`* Renderers processor gives an ability to render values and`
`69`	`69`	`* and add new renderers`
`70`	`70`	`*/`
`71`		`- val renderersProcessor: TypeRenderersProcessor`
	`71`	`+ val renderersProcessor: RenderersProcessor`
`72`	`72`	`}`