Remove LibraryFactory class

Fix resources processing, add tests
Decide how to resolve libraries "by default" just before resolution
Fix formatting

Author: ileasile

jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/libraries/libraryResources.kt

@@ -50,25 +50,25 @@ data class ResourceLocation(
 }
 
 @Serializable(ResourceBunchSerializer::class)
-data class ResourceFallbacksBunch(
+data class ResourceFallbacksBundle(
     val locations: List<ResourceLocation>,
-) : VariablesSubstitutionAware<ResourceFallbacksBunch> {
+) : VariablesSubstitutionAware<ResourceFallbacksBundle> {
     constructor(vararg locations: ResourceLocation) : this(listOf(*locations))
 
-    override fun replaceVariables(mapping: Map<String, String>): ResourceFallbacksBunch {
-        return ResourceFallbacksBunch(locations.map { it.replaceVariables(mapping) })
+    override fun replaceVariables(mapping: Map<String, String>): ResourceFallbacksBundle {
+        return ResourceFallbacksBundle(locations.map { it.replaceVariables(mapping) })
     }
 }
 
 @Serializable
 data class LibraryResource(
-    val bunches: List<ResourceFallbacksBunch>,
+    val bundles: List<ResourceFallbacksBundle>,
     val type: ResourceType,
     val name: String,
 ) : VariablesSubstitutionAware<LibraryResource> {
     override fun replaceVariables(mapping: Map<String, String>): LibraryResource {
         return LibraryResource(
-            bunches.map { it.replaceVariables(mapping) },
+            bundles.map { it.replaceVariables(mapping) },
             type,
             replaceVariables(name, mapping)
         )

jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/util/serializers.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlinx.jupyter.api.ExactRendererTypeHandler
 import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
 import org.jetbrains.kotlinx.jupyter.api.ResultHandlerCodeExecution
 import org.jetbrains.kotlinx.jupyter.api.libraries.CodeExecution
-import org.jetbrains.kotlinx.jupyter.api.libraries.ResourceFallbacksBunch
+import org.jetbrains.kotlinx.jupyter.api.libraries.ResourceFallbacksBundle
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty1
 
@@ -88,20 +88,20 @@ object KotlinKernelVersionSerializer : KSerializer<KotlinKernelVersion> {
     }
 }
 
-object ResourceBunchSerializer : KSerializer<ResourceFallbacksBunch> {
-    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(ResourceFallbacksBunch::class.qualifiedName!!, PrimitiveKind.STRING)
+object ResourceBunchSerializer : KSerializer<ResourceFallbacksBundle> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(ResourceFallbacksBundle::class.qualifiedName!!, PrimitiveKind.STRING)
 
-    override fun deserialize(decoder: Decoder): ResourceFallbacksBunch {
+    override fun deserialize(decoder: Decoder): ResourceFallbacksBundle {
         return when (val obj = decoder.decodeSerializableValue(serializer<JsonElement>())) {
             is JsonArray -> {
-                ResourceFallbacksBunch(
+                ResourceFallbacksBundle(
                     obj.map {
                         Json.decodeFromJsonElement(it)
                     }
                 )
             }
             is JsonObject -> {
-                ResourceFallbacksBunch(
+                ResourceFallbacksBundle(
                     listOf(
                         Json.decodeFromJsonElement(obj)
                     )
@@ -111,7 +111,7 @@ object ResourceBunchSerializer : KSerializer<ResourceFallbacksBunch> {
         }
     }
 
-    override fun serialize(encoder: Encoder, value: ResourceFallbacksBunch) {
+    override fun serialize(encoder: Encoder, value: ResourceFallbacksBundle) {
         encoder.encodeSerializableValue(serializer(), value.locations)
     }
 }

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/CssLibraryResourcesProcessor.kt

@@ -1,15 +1,15 @@
 package org.jetbrains.kotlinx.jupyter.libraries
 
 import org.jetbrains.kotlinx.jupyter.api.libraries.LibraryResource
-import org.jetbrains.kotlinx.jupyter.api.libraries.ResourceFallbacksBunch
+import org.jetbrains.kotlinx.jupyter.api.libraries.ResourceFallbacksBundle
 import org.jetbrains.kotlinx.jupyter.api.libraries.ResourcePathType
 import java.io.File
 import java.io.IOException
 
 class CssLibraryResourcesProcessor : LibraryResourcesProcessor {
-    private fun loadCssAsText(bunch: ResourceFallbacksBunch, classLoader: ClassLoader): String {
+    private fun loadCssAsText(bundle: ResourceFallbacksBundle, classLoader: ClassLoader): String {
         val exceptions = mutableListOf<Exception>()
-        for (resourceLocation in bunch.locations) {
+        for (resourceLocation in bundle.locations) {
             val path = resourceLocation.path
 
             fun wrapInTag(text: String) = """
@@ -37,6 +37,6 @@ class CssLibraryResourcesProcessor : LibraryResourcesProcessor {
     }
 
     override fun wrapLibrary(resource: LibraryResource, classLoader: ClassLoader): String {
-        return resource.bunches.joinToString("\n") { loadCssAsText(it, classLoader) }
+        return resource.bundles.joinToString("\n") { loadCssAsText(it, classLoader) }
     }
 }

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/JsLibraryResourcesProcessor.kt

@@ -5,7 +5,7 @@ import kotlinx.serialization.json.Json
 import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlinx.jupyter.api.Code
 import org.jetbrains.kotlinx.jupyter.api.libraries.LibraryResource
-import org.jetbrains.kotlinx.jupyter.api.libraries.ResourceFallbacksBunch
+import org.jetbrains.kotlinx.jupyter.api.libraries.ResourceFallbacksBundle
 import org.jetbrains.kotlinx.jupyter.api.libraries.ResourcePathType
 import org.jetbrains.kotlinx.jupyter.config.getLogger
 import java.io.File
@@ -14,9 +14,9 @@ import java.io.IOException
 class JsLibraryResourcesProcessor : LibraryResourcesProcessor {
     private var outputCounter = 0
 
-    private fun loadBunch(bunch: ResourceFallbacksBunch, classLoader: ClassLoader): ScriptModifierFunctionGenerator {
+    private fun loadBunch(bundle: ResourceFallbacksBundle, classLoader: ClassLoader): ScriptModifierFunctionGenerator {
         val exceptions = mutableListOf<Exception>()
-        for (resourceLocation in bunch.locations) {
+        for (resourceLocation in bundle.locations) {
             val path = resourceLocation.path
 
             return try {
@@ -47,7 +47,7 @@ class JsLibraryResourcesProcessor : LibraryResourcesProcessor {
     }
 
     private fun loadResourceAsText(resource: LibraryResource, classLoader: ClassLoader): List<ScriptModifierFunctionGenerator> {
-        return resource.bunches.map { loadBunch(it, classLoader) }
+        return resource.bundles.map { loadBunch(it, classLoader) }
     }
 
     override fun wrapLibrary(resource: LibraryResource, classLoader: ClassLoader): String {

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/LibrariesProcessor.kt

@@ -7,13 +7,11 @@ import org.jetbrains.kotlinx.jupyter.compiler.util.ReplCompilerException
 
 interface LibrariesProcessor {
     fun processNewLibraries(arg: String): List<LibraryDefinitionProducer>
-    val libraryFactory: LibraryFactory
 }
 
 class LibrariesProcessorImpl(
     private val libraries: LibraryResolver?,
     private val kernelVersion: KotlinKernelVersion?,
-    override val libraryFactory: LibraryFactory,
 ) : LibrariesProcessor {
 
     /**
@@ -63,7 +61,7 @@ class LibrariesProcessorImpl(
 
     override fun processNewLibraries(arg: String): List<LibraryDefinitionProducer> =
         splitLibraryCalls(arg).map {
-            val (libRef, vars) = libraryFactory.parseReferenceWithArgs(it)
+            val (libRef, vars) = parseReferenceWithArgs(it)
             val library = libraries?.resolve(libRef, vars)
                 ?: throw ReplCompilerException("Unknown library '$libRef'")
 

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/LibraryFactory.kt

@@ -14,8 +14,8 @@ data class LibraryReference(
         key = namePart + info.key
     }
 
-    fun resolve(): LibraryDefinition {
-        val text = info.resolve(name)
+    fun resolve(): LibraryDefinition? {
+        val text = info.resolve(name) ?: return null
         return parseLibraryDescriptor(text)
     }
 

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/LibraryReference.kt

@@ -70,12 +70,18 @@ abstract class LibraryResolutionInfo(
         }
     }
 
+    class Default(val string: String = "") : LibraryResolutionInfo("default") {
+        override val args: List<Variable> = listOf()
+
+        override fun resolve(name: String?): Nothing? = null
+    }
+
     protected abstract val args: List<Variable>
     protected open val valueKey: String
         get() = args.joinToString { it.value }
 
     val key: String by lazy { "${typeKey}_${replaceForbiddenChars(valueKey)}" }
-    abstract fun resolve(name: String?): String
+    abstract fun resolve(name: String?): String?
 
     override fun hashCode(): Int {
         return key.hashCode()

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/LibraryResolutionInfo.kt

@@ -18,8 +18,6 @@ abstract class LibraryDescriptorResolver(private val parent: LibraryResolver? =
     protected abstract fun save(reference: LibraryReference, definition: LibraryDefinition)
     protected open fun shouldResolve(reference: LibraryReference): Boolean = true
 
-    open val cache: Map<LibraryReference, LibraryDefinition>? = null
-
     override fun resolve(reference: LibraryReference, vars: List<Variable>): LibraryDefinition? {
         val shouldBeResolved = shouldResolve(reference)
         if (shouldBeResolved) {
@@ -80,16 +78,22 @@ abstract class LibraryDescriptorResolver(private val parent: LibraryResolver? =
             shutdown = library.shutdown.replaceVariables(mapping),
             initCell = library.initCell.replaceVariables(mapping),
             renderers = library.renderers.replaceVariables(mapping),
-            converters = library.converters,
             resources = library.resources.replaceVariables(mapping),
             minKernelVersion = library.minKernelVersion
         )
     }
 }
 
-class FallbackLibraryResolver : LibraryDescriptorResolver() {
-    override fun tryResolve(reference: LibraryReference): LibraryDefinition {
-        return reference.resolve()
+class FallbackLibraryResolver(private val infoProvider: ResolutionInfoProvider) : LibraryDescriptorResolver() {
+    override fun tryResolve(reference: LibraryReference): LibraryDefinition? {
+        val result = reference.resolve()
+        if (result != null) return result
+
+        val infoStub = reference.info
+        if (infoStub !is LibraryResolutionInfo.Default) return null
+
+        val info = infoProvider.get(infoStub.string)
+        return info.resolve(reference.name)?.let { parseLibraryDescriptor(it) }
     }
 
     override fun save(reference: LibraryReference, definition: LibraryDefinition) {

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/LibraryResolver.kt

@@ -6,8 +6,19 @@ import java.net.URL
 interface ResolutionInfoProvider {
     var fallback: LibraryResolutionInfo
 
-    fun get(): LibraryResolutionInfo = fallback
     fun get(string: String): LibraryResolutionInfo
+
+    companion object {
+        fun withDefaultDirectoryResolution(dir: File) = StandardResolutionInfoProvider(
+            LibraryResolutionInfo.ByDir(dir)
+        )
+
+        // Used in Kotlin Jupyter plugin for IDEA
+        @Suppress("unused")
+        fun withDefaultGitRefResolution(ref: String) = StandardResolutionInfoProvider(
+            LibraryResolutionInfo.getInfoByRef(ref)
+        )
+    }
 }
 
 object EmptyResolutionInfoProvider : ResolutionInfoProvider {
@@ -17,11 +28,15 @@ object EmptyResolutionInfoProvider : ResolutionInfoProvider {
         get() = fallbackInfo
         set(_) {}
 
-    override fun get(string: String) = LibraryResolutionInfo.getInfoByRef(string)
+    override fun get(string: String): LibraryResolutionInfo {
+        if (string.isEmpty()) return fallback
+        return LibraryResolutionInfo.getInfoByRef(string)
+    }
 }
 
 class StandardResolutionInfoProvider(override var fallback: LibraryResolutionInfo) : ResolutionInfoProvider {
     override fun get(string: String): LibraryResolutionInfo {
+        if (string.isEmpty()) return fallback
         return tryGetAsRef(string) ?: tryGetAsDir(string) ?: tryGetAsFile(string) ?: tryGetAsURL(string) ?: fallback
     }
 

jupyter-lib/shared-compiler/src/main/kotlin/org/jetbrains/kotlinx/jupyter/libraries/ResolutionInfoProvider.kt

@@ -0,0 +1,43 @@
+package org.jetbrains.kotlinx.jupyter.libraries
+
+import java.io.File
+import java.net.URL
+
+fun parseReferenceWithArgs(str: String): Pair<LibraryReference, List<Variable>> {
+    val (fullName, vars) = parseLibraryName(str)
+    val reference = parseReference(fullName)
+    return reference to vars
+}
+
+private fun parseResolutionInfo(string: String): LibraryResolutionInfo {
+    // In case of empty string after `@`: %use lib@
+    if (string.isBlank()) return LibraryResolutionInfo.Default()
+
+    val (type, vars) = parseCall(string, Brackets.SQUARE)
+    return defaultParsers[type]?.getInfo(vars) ?: LibraryResolutionInfo.Default(type)
+}
+
+private fun parseReference(string: String): LibraryReference {
+    val sepIndex = string.indexOf('@')
+    if (sepIndex == -1) return LibraryReference(LibraryResolutionInfo.Default(), string)
+
+    val nameString = string.substring(0, sepIndex)
+    val infoString = string.substring(sepIndex + 1)
+    val info = parseResolutionInfo(infoString)
+    return LibraryReference(info, nameString)
+}
+
+private val defaultParsers = listOf(
+    LibraryResolutionInfoParser.make("ref", listOf(Parameter.Required("ref"))) { args ->
+        LibraryResolutionInfo.getInfoByRef(args["ref"] ?: error("Argument 'ref' should be specified"))
+    },
+    LibraryResolutionInfoParser.make("file", listOf(Parameter.Required("path"))) { args ->
+        LibraryResolutionInfo.ByFile(File(args["path"] ?: error("Argument 'path' should be specified")))
+    },
+    LibraryResolutionInfoParser.make("dir", listOf(Parameter.Required("dir"))) { args ->
+        LibraryResolutionInfo.ByDir(File(args["dir"] ?: error("Argument 'dir' should be specified")))
+    },
+    LibraryResolutionInfoParser.make("url", listOf(Parameter.Required("url"))) { args ->
+        LibraryResolutionInfo.ByURL(URL(args["url"] ?: error("Argument 'url' should be specified")))
+    },
+).map { it.name to it }.toMap()