Rename ScriptingEnvironment to ScriptingHostConfiguration

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

@@ -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)
         }

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

@@ -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)