script.runtime: update api

- Clean up some api inconsistencies
 - Provide experimental async resolver to allow cleaner async updates of dependencies

core/script.runtime/src/kotlin/script/dependencies/dependencies.kt

@@ -19,43 +19,15 @@
 package kotlin.script.dependencies
 
 import java.io.File
-import java.util.Collections.emptyList
 
-interface KotlinScriptExternalDependencies : Comparable<KotlinScriptExternalDependencies> {
-    val javaHome: String? get() = null
-    val classpath: Iterable<File> get() = emptyList()
-    val imports: Iterable<String> get() = emptyList()
-    val sources: Iterable<File> get() = emptyList()
-    val scripts: Iterable<File> get() = emptyList()
-
-    override fun compareTo(other: KotlinScriptExternalDependencies): Int =
-            compareValues(javaHome, other.javaHome)
-                    .chainCompare { compareIterables(classpath, other.classpath) }
-                    .chainCompare { compareIterables(imports, other.imports) }
-                    .chainCompare { compareIterables(sources, other.sources) }
-                    .chainCompare { compareIterables(scripts, other.scripts) }
-}
-
-// copied form Comparisons.kt to resolve temporary build issues with dependency on stdlib
-private fun <T : Comparable<*>> compareValues(a: T?, b: T?): Int {
-    if (a === b) return 0
-    if (a == null) return -1
-    if (b == null) return 1
-
-    @Suppress("UNCHECKED_CAST")
-    return (a as Comparable<Any>).compareTo(b)
-}
-
-private fun<T: Comparable<T>> compareIterables(a: Iterable<T>, b: Iterable<T>): Int {
-    val ia = a.iterator()
-    val ib = b.iterator()
-    while (true) {
-        if (ia.hasNext() && !ib.hasNext()) return 1
-        if (!ia.hasNext() && !ib.hasNext()) return 0
-        if (!ia.hasNext()) return -1
-        val compRes = compareValues(ia.next(), ib.next())
-        if (compRes != 0) return compRes
+data class ScriptDependencies(
+        val javaHome: File? = null,
+        val classpath: List<File> = emptyList(),
+        val imports: List<String> = emptyList(),
+        val sources: List<File> = emptyList(),
+        val scripts: List<File> = emptyList()
+) {
+    companion object {
+        val Empty = ScriptDependencies()
     }
-}
-
-private inline fun Int.chainCompare(compFn: () -> Int ): Int = if (this != 0) this else compFn()
+}

core/script.runtime/src/kotlin/script/dependencies/experimental/AsyncDependenciesResolver.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:Suppress("unused")
+
+package kotlin.script.dependencies.experimental
+
+import kotlin.script.dependencies.DependenciesResolver
+import kotlin.script.dependencies.DependenciesResolver.ResolveResult
+import kotlin.script.dependencies.Environment
+import kotlin.script.dependencies.ScriptContents
+
+interface AsyncDependenciesResolver : DependenciesResolver {
+    suspend fun resolveAsync(
+            scriptContents: ScriptContents, environment: Environment
+    ): ResolveResult
+
+    /* 'resolve' implementation is supposed to invoke resolveAsync in a blocking manner
+    *  To avoid dependency on kotlinx-coroutines-core we leave this method unimplemented
+    *     and provide 'resolve' implementation when loading resolver.
+    */
+    override fun resolve(scriptContents: ScriptContents, environment: Environment): ResolveResult
+            = /*runBlocking { resolveAsync(scriptContents, environment) } */ throw NotImplementedError()
+}

core/script.runtime/src/kotlin/script/dependencies/resolvers.kt

@@ -19,36 +19,43 @@
 package kotlin.script.dependencies
 
 import java.io.File
-import java.util.concurrent.Future
-import java.util.concurrent.TimeUnit
+import kotlin.script.dependencies.DependenciesResolver.ResolveResult
 
-interface ScriptDependenciesResolver {
+typealias Environment = Map<String, Any?>
 
-    enum class ReportSeverity { ERROR, WARNING, INFO, DEBUG }
+interface DependenciesResolver {
+    fun resolve(scriptContents: ScriptContents, environment: Environment): ResolveResult
 
-    fun resolve(script: ScriptContents,
-                environment: Map<String, Any?>?,
-                report: (ReportSeverity, String, ScriptContents.Position?) -> Unit,
-                previousDependencies: KotlinScriptExternalDependencies?
-    ): Future<KotlinScriptExternalDependencies?> = PseudoFuture(null)
+    object NoDependencies : DependenciesResolver {
+        override fun resolve(scriptContents: ScriptContents, environment: Environment) = ScriptDependencies.Empty.asSuccess()
+    }
+
+    sealed class ResolveResult {
+        abstract val dependencies: ScriptDependencies?
+        abstract val reports: List<ScriptReport>
+
+        data class Success(
+                override val dependencies: ScriptDependencies,
+                override val reports: List<ScriptReport> = listOf()
+        ) : ResolveResult()
+
+        data class Failure(override val reports: List<ScriptReport>) : ResolveResult() {
+            constructor(vararg reports: ScriptReport) : this(reports.asList())
+
+            override val dependencies: ScriptDependencies? get() = null
+        }
+    }
 }
 
-class BasicScriptDependenciesResolver : ScriptDependenciesResolver
 interface ScriptContents {
-
-    data class Position(val line: Int, val col: Int)
-
     val file: File?
     val annotations: Iterable<Annotation>
     val text: CharSequence?
 }
 
-fun KotlinScriptExternalDependencies?.asFuture(): PseudoFuture<KotlinScriptExternalDependencies?> = PseudoFuture(this)
-
-class PseudoFuture<T>(private val value: T): Future<T> {
-    override fun get(): T = value
-    override fun get(p0: Long, p1: TimeUnit): T  = value
-    override fun cancel(p0: Boolean): Boolean = false
-    override fun isDone(): Boolean = true
-    override fun isCancelled(): Boolean = false
+data class ScriptReport(val message: String, val severity: Severity = ScriptReport.Severity.ERROR, val position: Position? = null) {
+    data class Position(val startLine: Int, val startColumn: Int, val endLine: Int? = null, val endColumn: Int? = null)
+    enum class Severity { ERROR, WARNING, INFO, DEBUG }
 }
+
+fun ScriptDependencies.asSuccess(): ResolveResult.Success = ResolveResult.Success(this)

core/script.runtime/src/kotlin/script/templates/annotations.kt

@@ -19,14 +19,13 @@
 package kotlin.script.templates
 
 import kotlin.reflect.KClass
-import kotlin.script.dependencies.BasicScriptDependenciesResolver
-import kotlin.script.dependencies.ScriptDependenciesResolver
+import kotlin.script.dependencies.DependenciesResolver
 
 const val DEFAULT_SCRIPT_FILE_PATTERN = ".*\\.kts"
 
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class ScriptTemplateDefinition(val resolver: KClass<out ScriptDependenciesResolver> = BasicScriptDependenciesResolver::class,
+annotation class ScriptTemplateDefinition(val resolver: KClass<out DependenciesResolver> = DependenciesResolver.NoDependencies::class,
                                           val scriptFilePattern: String = DEFAULT_SCRIPT_FILE_PATTERN)
 
 @Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS)