Rename ScriptingEnvironment to ScriptingHostConfiguration

2018-08-21 13:14:35 +03:00
parent 2fe5f78921
commit c2e6c0ed49
12 changed files with 72 additions and 61 deletions
@@ -3,7 +3,7 @@
 * that can be found in the license/LICENSE.txt file.
 */

-package kotlin.script.experimental.configuration
+package kotlin.script.experimental.host

 import kotlin.reflect.KClass
 import kotlin.script.experimental.annotations.KotlinScript
@@ -18,17 +18,17 @@ private const val ILLEGAL_CONFIG_ANN_ARG =

 fun createScriptCompilationConfigurationFromAnnotatedBaseClass(
    baseClassType: KotlinType,
-    environment: ScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration,
    contextClass: KClass<*> = ScriptCompilationConfiguration::class,
    body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration {

-    val getScriptingClass = environment[ScriptingEnvironment.getScriptingClass]
+    val getScriptingClass = hostConfiguration[ScriptingHostConfiguration.getScriptingClass]
        ?: throw IllegalArgumentException("${ERROR_MSG_PREFIX}Expecting 'getScriptingClass' parameter in the scripting environment")

    val baseClass: KClass<*> =
        try {
-            getScriptingClass(baseClassType, contextClass, environment)
+            getScriptingClass(baseClassType, contextClass, hostConfiguration)
        } catch (e: Throwable) {
            throw IllegalArgumentException("${ERROR_MSG_PREFIX}Unable to load base class $baseClassType", e)
        }
@@ -3,49 +3,51 @@
 * that can be found in the license/LICENSE.txt file.
 */

-package kotlin.script.experimental.api
+package kotlin.script.experimental.host

 import kotlin.reflect.KClass
+import kotlin.script.experimental.api.KotlinType
+import kotlin.script.experimental.api.ScriptDependency
 import kotlin.script.experimental.util.PropertiesCollection

-interface ScriptingEnvironmentKeys
+interface ScriptingHostConfigurationKeys

-class ScriptingEnvironment(baseScriptingEnvironments: Iterable<ScriptingEnvironment>, body: Builder.() -> Unit) :
+class ScriptingHostConfiguration(baseScriptingEnvironments: Iterable<ScriptingHostConfiguration>, body: Builder.() -> Unit) :
    PropertiesCollection(Builder(baseScriptingEnvironments).apply(body).data) {

    constructor(body: Builder.() -> Unit = {}) : this(emptyList(), body)
    constructor(
-        vararg baseScriptingEnvironments: ScriptingEnvironment, body: Builder.() -> Unit = {}
-    ) : this(baseScriptingEnvironments.asIterable(), body)
+        vararg baseConfigurations: ScriptingHostConfiguration, body: Builder.() -> Unit = {}
+    ) : this(baseConfigurations.asIterable(), body)

-    class Builder internal constructor(baseScriptingEnvironments: Iterable<ScriptingEnvironment>) : 
-        ScriptingEnvironmentKeys, 
+    class Builder internal constructor(baseScriptingEnvironments: Iterable<ScriptingHostConfiguration>) :
+        ScriptingHostConfigurationKeys,
        PropertiesCollection.Builder(baseScriptingEnvironments)
    
-    companion object : ScriptingEnvironmentKeys
+    companion object : ScriptingHostConfigurationKeys
 }

 // should contain all dependencies needed for baseClass and compilationConfigurator
-val ScriptingEnvironmentKeys.configurationDependencies by PropertiesCollection.key<List<ScriptDependency>>()
+val ScriptingHostConfigurationKeys.configurationDependencies by PropertiesCollection.key<List<ScriptDependency>>()

 // do not use configurationDependencies as script dependencies, so only the dependencies defined by compilationConfigurator will be used
 // (NOTE: in this case they should include the dependencies for the base class anyway, since this class is needed for script
 // compilation and instantiation, but compilationConfigurator could be excluded)
-val ScriptingEnvironmentKeys.isolatedDependencies by PropertiesCollection.key<Boolean>(false)
+val ScriptingHostConfigurationKeys.isolatedDependencies by PropertiesCollection.key<Boolean>(false)

 // a "class loader" for KotlinTypes
-val ScriptingEnvironmentKeys.getScriptingClass by PropertiesCollection.key<GetScriptingClass>()
+val ScriptingHostConfigurationKeys.getScriptingClass by PropertiesCollection.key<GetScriptingClass>()


 interface GetScriptingClass {
-    operator fun invoke(classType: KotlinType, contextClass: KClass<*>, environment: ScriptingEnvironment): KClass<*>
+    operator fun invoke(classType: KotlinType, contextClass: KClass<*>, hostConfiguration: ScriptingHostConfiguration): KClass<*>
 }

-fun ScriptingEnvironment.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> {
-    val getClass = get(ScriptingEnvironment.getScriptingClass)
+fun ScriptingHostConfiguration.getScriptingClass(type: KotlinType, contextClass: KClass<*>): KClass<*> {
+    val getClass = get(ScriptingHostConfiguration.getScriptingClass)
        ?: throw IllegalArgumentException("Expecting 'getScriptingClass' property in the scripting environment: unable to load scripting class $type")
    return getClass(type, contextClass, this)
 }

-fun ScriptingEnvironment.getScriptingClass(type: KotlinType, context: Any): KClass<*> = getScriptingClass(type, context::class)
+fun ScriptingHostConfiguration.getScriptingClass(type: KotlinType, context: Any): KClass<*> = getScriptingClass(type, context::class)

@@ -8,24 +8,24 @@ package kotlin.script.experimental.jvmhost
 import kotlin.script.experimental.api.KotlinType
 import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.ScriptEvaluator
-import kotlin.script.experimental.api.ScriptingEnvironment
-import kotlin.script.experimental.configuration.createScriptCompilationConfigurationFromAnnotatedBaseClass
+import kotlin.script.experimental.host.ScriptingHostConfiguration
+import kotlin.script.experimental.host.createScriptCompilationConfigurationFromAnnotatedBaseClass
 import kotlin.script.experimental.host.BasicScriptingHost
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment

 open class BasicJvmScriptingHost(
-    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
-    compiler: JvmScriptCompiler = JvmScriptCompiler(hostEnvironment),
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingEnvironment,
+    compiler: JvmScriptCompiler = JvmScriptCompiler(hostConfiguration),
    evaluator: ScriptEvaluator = BasicJvmScriptEvaluator()
 ) : BasicScriptingHost(compiler, evaluator)


 inline fun <reified T : Any> createBasicScriptCompilationConfigurationFromAnnotatedBaseClass(
-    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingEnvironment,
    noinline body: ScriptCompilationConfiguration.Builder.() -> Unit = {}
 ): ScriptCompilationConfiguration = createScriptCompilationConfigurationFromAnnotatedBaseClass(
    KotlinType(T::class),
-    hostEnvironment,
+    hostConfiguration,
    ScriptCompilationConfiguration::class,
    body
 )
@@ -38,7 +38,9 @@ import java.io.File
 import java.net.URLClassLoader
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.dependencies.DependenciesResolver
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.host.getMergedScriptText
+import kotlin.script.experimental.host.getScriptingClass
 import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.impl.BridgeDependenciesResolver
 import kotlin.script.experimental.jvm.javaHome
@@ -74,7 +76,7 @@ class KJvmCompiledScript<out ScriptBase : Any>(
    }
 }

-class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompilerProxy {
+class KJvmCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) : KJvmCompilerProxy {

    override fun compile(
        script: ScriptSource,
@@ -104,13 +106,13 @@ class KJvmCompilerImpl(val hostEnvironment: ScriptingEnvironment) : KJvmCompiler
            val kotlinCompilerConfiguration = org.jetbrains.kotlin.config.CompilerConfiguration().apply {
                add(
                    JVMConfigurationKeys.SCRIPT_DEFINITIONS,
-                    BridgeScriptDefinition(scriptCompilationConfiguration, hostEnvironment, ::updateClasspath)
+                    BridgeScriptDefinition(scriptCompilationConfiguration, hostConfiguration, ::updateClasspath)
                )
                put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
                put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)

                var isModularJava = false
-                getFirstFromChainOrNull(ScriptCompilationConfiguration.jvm.javaHome, updatedConfiguration, hostEnvironment)?.let {
+                getFirstFromChainOrNull(ScriptCompilationConfiguration.jvm.javaHome, updatedConfiguration, hostConfiguration)?.let {
                    put(JVMConfigurationKeys.JDK_HOME, it)
                    isModularJava = CoreJrtFileSystem.isModularJdk(it)
                }
@@ -238,10 +240,10 @@ class ScriptDiagnosticsMessageCollector : MessageCollector {

 internal class BridgeScriptDefinition(
    scriptCompilationConfiguration: ScriptCompilationConfiguration,
-    hostEnvironment: ScriptingEnvironment,
+    hostConfiguration: ScriptingHostConfiguration,
    updateClasspath: (List<File>) -> Unit
 ) : KotlinScriptDefinition(
-    hostEnvironment.getScriptingClass(
+    hostConfiguration.getScriptingClass(
        scriptCompilationConfiguration.getOrError(ScriptCompilationConfiguration.baseClass),
        BridgeScriptDefinition::class
    )
@@ -5,14 +5,14 @@

 package kotlin.script.experimental.jvmhost.impl

-import kotlin.script.experimental.api.ScriptingEnvironment
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment

-fun ScriptingEnvironment.withDefaults(): ScriptingEnvironment =
+fun ScriptingHostConfiguration.withDefaults(): ScriptingHostConfiguration =
    if (this == defaultJvmScriptingEnvironment || defaultJvmScriptingEnvironment.properties.all {
            this.properties.containsKey(it.key)
        }) {
        this
    } else {
-        ScriptingEnvironment(defaultJvmScriptingEnvironment, this)
+        ScriptingHostConfiguration(defaultJvmScriptingEnvironment, this)
    }
@@ -8,6 +8,7 @@
 package kotlin.script.experimental.jvmhost

 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.jvm.defaultJvmScriptingEnvironment
 import kotlin.script.experimental.jvmhost.impl.KJvmCompilerImpl
 import kotlin.script.experimental.jvmhost.impl.withDefaults
@@ -29,8 +30,8 @@ interface CompiledJvmScriptsCache {
 }

 open class JvmScriptCompiler(
-    hostEnvironment: ScriptingEnvironment = defaultJvmScriptingEnvironment,
-    val compilerProxy: KJvmCompilerProxy = KJvmCompilerImpl(hostEnvironment.withDefaults()),
+    hostConfiguration: ScriptingHostConfiguration = defaultJvmScriptingEnvironment,
+    val compilerProxy: KJvmCompilerProxy = KJvmCompilerImpl(hostConfiguration.withDefaults()),
    val cache: CompiledJvmScriptsCache = CompiledJvmScriptsCache.NoCache
 ) : ScriptCompiler {

@@ -8,6 +8,7 @@ package kotlin.script.experimental.jvm
 import org.jetbrains.kotlin.script.util.scriptCompilationClasspathFromContext
 import java.io.File
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.ScriptingHostConfiguration
 import kotlin.script.experimental.util.PropertiesCollection

 data class JvmDependency(val classpath: List<File>) : ScriptDependency {
@@ -37,7 +38,7 @@ fun JvmScriptCompilationConfigurationBuilder.dependenciesFromClassloader(
    )
 }

-val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingEnvironment.jvm.javaHome)
+val JvmScriptCompilationConfigurationKeys.javaHome by PropertiesCollection.keyCopy(ScriptingHostConfiguration.jvm.javaHome)

@Suppress("unused")
 val ScriptCompilationConfigurationKeys.jvm
@@ -9,24 +9,25 @@ import java.io.File
 import java.net.URLClassLoader
 import kotlin.reflect.KClass
 import kotlin.script.experimental.api.*
+import kotlin.script.experimental.host.*
 import kotlin.script.experimental.util.PropertiesCollection

-interface JvmScriptingEnvironmentKeys
+interface JvmScriptingHostConfigurationKeys

-open class JvmScriptingEnvironmentBuilder : JvmScriptingEnvironmentKeys, PropertiesCollection.Builder() {
+open class JvmScriptingHostConfigurationBuilder : JvmScriptingHostConfigurationKeys, PropertiesCollection.Builder() {

-    companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptingEnvironmentBuilder>, JvmScriptingEnvironmentKeys {
-        override fun get() = JvmScriptingEnvironmentBuilder()
+    companion object : PropertiesCollection.Builder.BuilderExtension<JvmScriptingHostConfigurationBuilder>, JvmScriptingHostConfigurationKeys {
+        override fun get() = JvmScriptingHostConfigurationBuilder()
    }
 }

-val JvmScriptingEnvironmentKeys.javaHome by PropertiesCollection.key<File>(File(System.getProperty("java.home")))
+val JvmScriptingHostConfigurationKeys.javaHome by PropertiesCollection.key<File>(File(System.getProperty("java.home")))

@Suppress("unused")
-val ScriptingEnvironmentKeys.jvm
-    get() = JvmScriptingEnvironmentBuilder
+val ScriptingHostConfigurationKeys.jvm
+    get() = JvmScriptingHostConfigurationBuilder

-val defaultJvmScriptingEnvironment = ScriptingEnvironment {
+val defaultJvmScriptingEnvironment = ScriptingHostConfiguration {
    getScriptingClass(JvmGetScriptingClass())
 }

@@ -38,7 +39,7 @@ class JvmGetScriptingClass : GetScriptingClass {
    private var baseClassLoader: ClassLoader? = null

    @Synchronized
-    override fun invoke(classType: KotlinType, contextClass: KClass<*>, environment: ScriptingEnvironment): KClass<*> {
+    override fun invoke(classType: KotlinType, contextClass: KClass<*>, hostConfiguration: ScriptingHostConfiguration): KClass<*> {

        // checking if class already loaded in the same context
        val contextClassloader = contextClass.java.classLoader
@@ -49,7 +50,7 @@ class JvmGetScriptingClass : GetScriptingClass {
            if (actualClassLoadersChain.any { it == fromClass.java.classLoader }) return fromClass
        }

-        val newDeps = environment[ScriptingEnvironment.configurationDependencies]
+        val newDeps = hostConfiguration[ScriptingHostConfiguration.configurationDependencies]
        if (dependencies == null) {
            dependencies = newDeps
        } else {