Refactor context classpath discovery, share it to idea's jsr223 host...

...from script-util
fix daemon usage in repls
define compiler classpath for script-util tests explicitly
minor refactorings in the build scripts for better import into idea

libraries/tools/kotlin-script-util/src/test/kotlin/org/jetbrains/kotlin/script/util/ScriptUtilContextTests.kt

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.script.util
+
+import org.junit.Assert
+import org.junit.Test
+
+class ScriptUtilContextTests {
+
+    @Test
+    fun testExplicitScriptClasspath() {
+        withSysProp(KOTLIN_SCRIPT_CLASSPATH_PROPERTY, "a:b:c") {
+            val classpath = scriptCompilationClasspathFromContext()
+            Assert.assertEquals("a:b:c", classpath.joinToString(":"))
+        }
+    }
+
+    // TODO: more tests
+}
+
+private fun withSysProp(name: String, value: String, body: () -> Unit) {
+    val savedValue = System.setProperty(name, value)
+    try {
+        body()
+    }
+    finally {
+        if (savedValue != null) System.setProperty(name, savedValue)
+        else System.clearProperty(name)
+    }
+}

libraries/tools/kotlin-script-util/src/test/kotlin/org/jetbrains/kotlin/script/util/ScriptUtilIT.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.script.util
 
+import com.intellij.openapi.util.Disposer
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
@@ -24,7 +25,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.codegen.CompilationException
-import com.intellij.openapi.util.Disposer
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
@@ -34,16 +34,13 @@ import org.jetbrains.kotlin.script.KotlinScriptDefinitionFromAnnotatedTemplate
 import org.jetbrains.kotlin.script.util.templates.BindingsScriptTemplateWithLocalResolving
 import org.jetbrains.kotlin.script.util.templates.StandardArgsScriptTemplateWithLocalResolving
 import org.jetbrains.kotlin.script.util.templates.StandardArgsScriptTemplateWithMavenResolving
-import org.jetbrains.kotlin.utils.PathUtil
-//import org.jetbrains.kotlin.utils.PathUtil.KOTLIN_JAVA_RUNTIME_JAR
 import org.jetbrains.kotlin.utils.PathUtil.getResourcePathForClass
 import org.junit.Assert
 import org.junit.Test
-import java.io.*
-import java.net.URI
-import java.util.jar.Manifest
+import java.io.ByteArrayOutputStream
+import java.io.OutputStream
+import java.io.PrintStream
 import kotlin.reflect.KClass
-import kotlin.test.*
 
 const val KOTLIN_JAVA_RUNTIME_JAR = "kotlin-stdlib.jar"
 
@@ -101,7 +98,7 @@ done
 
         val scriptClass = compileScript("args-junit-hello-world.kts", StandardArgsScriptTemplateWithMavenResolving::class)
         if (scriptClass == null) {
-            System.err.println(contextClasspath(KOTLIN_JAVA_RUNTIME_JAR, Thread.currentThread().contextClassLoader)?.joinToString())
+            System.err.println(classpathFromClassloader(Thread.currentThread().contextClassLoader)?.takeIfContainsAll(KOTLIN_JAVA_RUNTIME_JAR)?.joinToString())
         }
         Assert.assertNotNull(scriptClass)
         captureOut {
@@ -132,7 +129,7 @@ done
         val rootDisposable = Disposer.newDisposable()
         try {
             val configuration = CompilerConfiguration().apply {
-                contextClasspath(KOTLIN_JAVA_RUNTIME_JAR, Thread.currentThread().contextClassLoader)?.let {
+                classpathFromClassloader(Thread.currentThread().contextClassLoader)?.takeIfContainsAll(KOTLIN_JAVA_RUNTIME_JAR)?.let {
                     addJvmClasspathRoots(it)
                 }
 
@@ -142,13 +139,6 @@ done
                     if (it.exists()) {
                         addJvmClasspathRoot(it)
                     }
-                    else {
-                        // attempt to workaround some maven quirks
-                        manifestClassPath(Thread.currentThread().contextClassLoader)?.let {
-                            val files = it.filter { it.name.startsWith("kotlin-") }
-                            addJvmClasspathRoots(files)
-                        }
-                    }
                 }
                 put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script-util-test")
                 add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, scriptDefinition)
@@ -206,14 +196,3 @@ private class NullOutputStream : OutputStream() {
     override fun write(b: ByteArray, off: Int, len: Int) { }
 }
 
-private fun <T> Iterable<T>.anyOrNull(predicate: (T) -> Boolean) = if (any(predicate)) this else null
-
-private fun File.matchMaybeVersionedFile(baseName: String) =
-        name == baseName ||
-                name == baseName.removeSuffix(".jar") || // for classes dirs
-                name.startsWith(baseName.removeSuffix(".jar") + "-")
-
-private fun contextClasspath(keyName: String, classLoader: ClassLoader): List<File>? =
-        ( classpathFromClassloader(classLoader)?.anyOrNull { it.matchMaybeVersionedFile(keyName) }
-          ?: manifestClassPath(classLoader)?.anyOrNull { it.matchMaybeVersionedFile(keyName) }
-        )?.toList()