Extend evaluation API for easier passing of evaluation configuration

refactor helpers accordingly

libraries/scripting/common/src/kotlin/script/experimental/annotations/scriptAnnotations.kt

@@ -9,6 +9,7 @@ package kotlin.script.experimental.annotations
 
 import kotlin.reflect.KClass
 import kotlin.script.experimental.api.ScriptCompilationConfiguration
+import kotlin.script.experimental.api.ScriptEvaluationConfiguration
 
 /**
  * The annotation for declaring a script definition (template)
@@ -26,6 +27,8 @@ import kotlin.script.experimental.api.ScriptCompilationConfiguration
  *        default - "kts"
  * @param compilationConfiguration an object or a class with default constructor containing initial script compilation configuration
  *        default - {@link ScriptCompilationConfiguration#Default}
+ * @param evaluationConfiguration an object or a class with default constructor containing initial script evaluation configuration
+ *        default - {@link ScriptEvaluationConfiguration#Default}
  *
  * Simple usage example:
  * <pre>
@@ -44,6 +47,7 @@ import kotlin.script.experimental.api.ScriptCompilationConfiguration
 annotation class KotlinScript(
     val displayName: String = "Kotlin script",
     val fileExtension: String = "kts",
-    val compilationConfiguration: KClass<out ScriptCompilationConfiguration> = ScriptCompilationConfiguration.Default::class
+    val compilationConfiguration: KClass<out ScriptCompilationConfiguration> = ScriptCompilationConfiguration.Default::class,
+    val evaluationConfiguration: KClass<out ScriptEvaluationConfiguration> = ScriptEvaluationConfiguration.Default::class
 )
 

libraries/scripting/common/src/kotlin/script/experimental/api/scriptEvaluation.kt

@@ -17,7 +17,7 @@ interface ScriptEvaluationConfigurationKeys
  * The container for script evaluation configuration
  * For usages see actual code examples
  */
-class ScriptEvaluationConfiguration(baseEvaluationConfigurations: Iterable<ScriptEvaluationConfiguration>, body: Builder.() -> Unit) :
+open class ScriptEvaluationConfiguration(baseEvaluationConfigurations: Iterable<ScriptEvaluationConfiguration>, body: Builder.() -> Unit) :
     PropertiesCollection(Builder(baseEvaluationConfigurations).apply(body).data) {
 
     constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
@@ -30,6 +30,8 @@ class ScriptEvaluationConfiguration(baseEvaluationConfigurations: Iterable<Scrip
         PropertiesCollection.Builder(baseEvaluationConfigurations)
 
     companion object : ScriptEvaluationConfigurationKeys
+
+    object Default : ScriptEvaluationConfiguration()
 }
 
 /**
@@ -116,6 +118,6 @@ interface ScriptEvaluator {
      */
     suspend operator fun invoke(
         compiledScript: CompiledScript<*>,
-        scriptEvaluationConfiguration: ScriptEvaluationConfiguration?
+        scriptEvaluationConfiguration: ScriptEvaluationConfiguration = ScriptEvaluationConfiguration.Default
     ): ResultWithDiagnostics<EvaluationResult>
 }

libraries/scripting/common/src/kotlin/script/experimental/host/BasicScriptingHost.kt

@@ -39,12 +39,12 @@ abstract class BasicScriptingHost(
      */
     open fun eval(
         script: SourceCode,
-        scriptCompilationConfiguration: ScriptCompilationConfiguration,
+        compilationConfiguration: ScriptCompilationConfiguration,
-        configuration: ScriptEvaluationConfiguration?
+        evaluationConfiguration: ScriptEvaluationConfiguration?
     ): ResultWithDiagnostics<EvaluationResult> =
         runInCoroutineContext {
-            compiler(script, scriptCompilationConfiguration).onSuccess {
+            compiler(script, compilationConfiguration).onSuccess {
-                evaluator(it, configuration)
+                evaluator(it, evaluationConfiguration ?: ScriptEvaluationConfiguration.Default)
             }
         }
 }

libraries/scripting/common/src/kotlin/script/experimental/host/configurationFromTemplate.kt

@@ -8,6 +8,7 @@ package kotlin.script.experimental.host
 import kotlin.reflect.KClass
 import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.util.PropertiesCollection
 
 private const val ERROR_MSG_PREFIX = "Unable to construct script definition: "
 
@@ -20,7 +21,7 @@ private const val SCRIPT_RUNTIME_TEMPLATES_PACKAGE = "kotlin.script.templates.st
 private abstract class DummyScriptTemplate
 
 /**
- * Creates the compilation configuration from annotated script base class
+ * Creates compilation configuration from annotated script base class
  * @param baseClassType the annotated script base class to construct the configuration from
  * @param hostConfiguration scripting host configuration properties
  * @param contextClass optional context class to extract classloading strategy from
@@ -33,48 +34,70 @@ fun createCompilationConfigurationFromTemplate(
     body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration {
 
+    val templateClass: KClass<*> = baseClassType.getTemplateClass(hostConfiguration, contextClass)
+
+    val mainAnnotation: KotlinScript = templateClass.kotlinScriptAnnotation
+
+    return ScriptCompilationConfiguration(scriptConfigInstance(mainAnnotation.compilationConfiguration)) {
+        propertiesFromTemplate(templateClass, baseClassType, mainAnnotation)
+        body()
+    }
+}
+
+/**
+ * Creates evaluation configuration from annotated script base class
+ * @param baseClassType the annotated script base class to construct the configuration from
+ * @param hostConfiguration scripting host configuration properties
+ * @param contextClass optional context class to extract classloading strategy from
+ * @param body optional configuration function to add more properties to the evaluation configuration
+ */
+fun createEvaluationConfigurationFromTemplate(
+    baseClassType: KotlinType,
+    hostConfiguration: ScriptingHostConfiguration,
+    contextClass: KClass<*> = ScriptEvaluationConfiguration::class,
+    body: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
+): ScriptEvaluationConfiguration {
+
+    val templateClass: KClass<*> = baseClassType.getTemplateClass(hostConfiguration, contextClass)
+
+    val mainAnnotation = templateClass.kotlinScriptAnnotation
+
+    return ScriptEvaluationConfiguration(scriptConfigInstance(mainAnnotation.evaluationConfiguration), body = body)
+}
+
+private fun ScriptCompilationConfiguration.Builder.propertiesFromTemplate(
+    templateClass: KClass<*>, baseClassType: KotlinType, mainAnnotation: KotlinScript
+) {
+    if (baseClass() == null) {
+        baseClass(if (templateClass == baseClassType.fromClass) baseClassType else KotlinType(templateClass))
+    }
+    if (fileExtension() == null) {
+        fileExtension(mainAnnotation.fileExtension)
+    }
+    if (displayName() == null) {
+        displayName(mainAnnotation.displayName)
+    }
+}
+
+private val KClass<*>.kotlinScriptAnnotation: KotlinScript
+    get() = findAnnotation()
+        ?: when (this@kotlinScriptAnnotation.qualifiedName) {
+            // transitions to the new scripting API: substituting annotations for standard templates from script-runtime
+            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.SimpleScriptTemplate",
+            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithArgs",
+            "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithBindings" -> DummyScriptTemplate::class.findAnnotation<KotlinScript>()
+            else -> null
+        }
+        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the ${this}")
+
+private fun KotlinType.getTemplateClass(hostConfiguration: ScriptingHostConfiguration, contextClass: KClass<*>): KClass<*> {
     val getScriptingClass = hostConfiguration[ScriptingHostConfiguration.getScriptingClass]
         ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting host configuration")
 
-    val baseClass: KClass<*> =
+    return try {
-        try {
+        getScriptingClass(this, contextClass, hostConfiguration)
-            getScriptingClass(baseClassType, contextClass, hostConfiguration)
-        } catch (e: Throwable) {
-            throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class $baseClassType", e)
-        }
-    val loadedBaseClassType = if (baseClass == baseClassType.fromClass) baseClassType else KotlinType(baseClass)
-
-    val mainAnnotation = baseClass.findAnnotation<KotlinScript>()
-        ?: run {
-            // transitions to the new scripting API:
-            // substituting annotations for standard templates from script-runtime
-            when (baseClass.qualifiedName) {
-                "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.SimpleScriptTemplate",
-                "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithArgs",
-                "$SCRIPT_RUNTIME_TEMPLATES_PACKAGE.ScriptTemplateWithBindings" -> DummyScriptTemplate::class
-                else -> null
-            }?.findAnnotation<KotlinScript>()
-        }
-        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting KotlinScript annotation on the $baseClass")
-
-    fun scriptConfigInstance(kclass: KClass<out ScriptCompilationConfiguration>): ScriptCompilationConfiguration = try {
-        kclass.objectInstance ?: kclass.createInstance()
     } catch (e: Throwable) {
-        throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: ${e.message}", e)
+        throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class ${this}", e)
-    }
-
-    return ScriptCompilationConfiguration(scriptConfigInstance(mainAnnotation.compilationConfiguration)) {
-        if (baseClass() == null) {
-            baseClass(loadedBaseClassType)
-        }
-        if (fileExtension() == null) {
-            fileExtension(mainAnnotation.fileExtension)
-        }
-        if (displayName() == null) {
-            displayName(mainAnnotation.displayName)
-        }
-
-        body()
     }
 }
 
@@ -90,3 +113,10 @@ private fun <T : Any> KClass<T>.createInstance(): T {
     @Suppress("UNCHECKED_CAST")
     return noArgsConstructor.newInstance() as T
 }
+
+private fun <T : PropertiesCollection> scriptConfigInstance(kclass: KClass<out T>): T = try {
+    kclass.objectInstance ?: kclass.createInstance()
+} catch (e: Throwable) {
+    throw IllegalArgumentException("$ILLEGAL_CONFIG_ANN_ARG: ${e.message}", e)
+}
+

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/BasicJvmScriptingHost.kt

@@ -5,19 +5,30 @@
 
 package kotlin.script.experimental.jvmhost
 
-import kotlin.script.experimental.api.KotlinType
+import kotlin.script.experimental.api.*
-import kotlin.script.experimental.api.ScriptCompilationConfiguration
-import kotlin.script.experimental.api.ScriptEvaluator
 import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.host.createCompilationConfigurationFromTemplate
 import kotlin.script.experimental.host.BasicScriptingHost
+import kotlin.script.experimental.host.createEvaluationConfigurationFromTemplate
 import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
 
 open class BasicJvmScriptingHost(
-    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingHostConfiguration,
+    val hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingHostConfiguration,
     compiler: JvmScriptCompiler = JvmScriptCompiler(hostConfiguration),
     evaluator: ScriptEvaluator = BasicJvmScriptEvaluator()
-) : BasicScriptingHost(compiler, evaluator)
+) : BasicScriptingHost(compiler, evaluator) {
+
+    inline fun <reified T : Any> evalWithTemplate(
+        script: SourceCode,
+        noinline compilation: ScriptCompilationConfiguration.Builder.() -> Unit = {},
+        noinline evaluation: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
+    ): ResultWithDiagnostics<EvaluationResult> =
+        eval(
+            script,
+            createJvmCompilationConfigurationFromTemplate<T>(hostConfiguration, compilation),
+            createJvmEvaluationConfigurationFromTemplate<T>(hostConfiguration, evaluation)
+        )
+}
 
 
 inline fun <reified T : Any> createJvmCompilationConfigurationFromTemplate(
@@ -29,3 +40,13 @@ inline fun <reified T : Any> createJvmCompilationConfigurationFromTemplate(
     ScriptCompilationConfiguration::class,
     body
 )
+
+inline fun <reified T : Any> createJvmEvaluationConfigurationFromTemplate(
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingHostConfiguration,
+    noinline body: ScriptEvaluationConfiguration.Builder.() -> Unit = {}
+): ScriptEvaluationConfiguration = createEvaluationConfigurationFromTemplate(
+    KotlinType(T::class),
+    hostConfiguration,
+    ScriptCompilationConfiguration::class,
+    body
+)

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptEvaluation.kt

@@ -28,11 +28,10 @@ open class BasicJvmScriptEvaluator : ScriptEvaluator {
 
     override suspend operator fun invoke(
         compiledScript: CompiledScript<*>,
-        scriptEvaluationConfiguration: ScriptEvaluationConfiguration?
+        scriptEvaluationConfiguration: ScriptEvaluationConfiguration
     ): ResultWithDiagnostics<EvaluationResult> =
         try {
-            val actualEvalConfiguration = scriptEvaluationConfiguration ?: ScriptEvaluationConfiguration()
+            compiledScript.getClass(scriptEvaluationConfiguration).onSuccess { scriptClass ->
-            compiledScript.getClass(actualEvalConfiguration).onSuccess { scriptClass ->
                 // in the future, when (if) we'll stop to compile everything into constructor
                 // run as SAM
                 // return res
@@ -40,14 +39,14 @@ open class BasicJvmScriptEvaluator : ScriptEvaluator {
                 // for other scripts we need evaluation configuration with actualClassloader set,
                 // so they are loaded in the same classloader as the "main" script
                 val updatedEvalConfiguration =
-                    if (actualEvalConfiguration.containsKey(ScriptEvaluationConfiguration.jvm.actualClassLoader))
+                    if (scriptEvaluationConfiguration.containsKey(ScriptEvaluationConfiguration.jvm.actualClassLoader))
-                        actualEvalConfiguration
+                        scriptEvaluationConfiguration
                     else
-                        ScriptEvaluationConfiguration(actualEvalConfiguration) {
+                        ScriptEvaluationConfiguration(scriptEvaluationConfiguration) {
                             ScriptEvaluationConfiguration.jvm.actualClassLoader(scriptClass.java.classLoader)
                         }
 
-                val sharedScripts = actualEvalConfiguration[ScriptEvaluationConfiguration.scriptsInstancesSharingMap]
+                val sharedScripts = scriptEvaluationConfiguration[ScriptEvaluationConfiguration.scriptsInstancesSharingMap]
 
                 sharedScripts?.get(scriptClass)?.asSuccess()
                     ?: compiledScript.otherScripts.mapSuccess {

libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/jvmScriptSaving.kt

@@ -20,7 +20,7 @@ open class BasicJvmScriptClassFilesGenerator(val outputDir: File) : ScriptEvalua
 
     override suspend operator fun invoke(
         compiledScript: CompiledScript<*>,
-        scriptEvaluationConfiguration: ScriptEvaluationConfiguration?
+        scriptEvaluationConfiguration: ScriptEvaluationConfiguration
     ): ResultWithDiagnostics<EvaluationResult> {
         try {
             if (compiledScript !is KJvmCompiledScript<*>)
@@ -48,7 +48,7 @@ open class BasicJvmScriptJarGenerator(val outputJar: File) : ScriptEvaluator {
 
     override suspend operator fun invoke(
         compiledScript: CompiledScript<*>,
-        scriptEvaluationConfiguration: ScriptEvaluationConfiguration?
+        scriptEvaluationConfiguration: ScriptEvaluationConfiguration
     ): ResultWithDiagnostics<EvaluationResult> {
         try {
             if (compiledScript !is KJvmCompiledScript<*>)

libraries/scripting/jvm-host/test/kotlin/script/experimental/jvmhost/test/ScriptingHostTest.kt

@@ -37,6 +37,11 @@ class ScriptingHostTest : TestCase() {
             evalScript("println(\"$greeting\")").throwOnFailure()
         }
         Assert.assertEquals(greeting, output)
+        // another API
+        val output2 = captureOut {
+            BasicJvmScriptingHost().evalWithTemplate<SimpleScriptTemplate>("println(\"$greeting\")".toScriptSource()).throwOnFailure()
+        }
+        Assert.assertEquals(greeting, output2)
     }
 
     @Test
@@ -276,7 +281,7 @@ class ScriptingHostTest : TestCase() {
             runBlocking {
                 compiler(script.toScriptSource(), scriptCompilationConfiguration).onSuccess {
                     compiledScript = it
-                    evaluator(it, null)
+                    evaluator(it)
                 }.throwOnFailure()
             }
         }.lines()
@@ -296,7 +301,7 @@ class ScriptingHostTest : TestCase() {
 
         val output2 = captureOut {
             runBlocking {
-                evaluator(cachedScript!!, null).throwOnFailure()
+                evaluator(cachedScript!!).throwOnFailure()
             }
         }.lines()
         Assert.assertEquals(output, output2)