I'm seeing a strange problem with this:

fun gitComplete(line: String, cursorIndex: Int): List<String> {
    val words = line.split(" ")
    if (words[0] == "git") return listOf("commit", "status")
            else return emptyList()
}

val result = if (args.size == 2) gitComplete(args[0], args[1].toInt())
    else emptyList()

result

The script above returns a valid result (a list of strings), but if I remove the intermediate

result

variable:

fun gitComplete(line: String, cursorIndex: Int): List<String> {
    val words = line.split(" ")
    if (words[0] == "git") return listOf("commit", "status")
            else return emptyList()
}

if (args.size == 2) gitComplete(args[0], args[1].toInt())
    else emptyList()

then the result of the evaluation by the engine is

null

.

Is there any documentation on how to customize completions, etc inside a script ? 🙂

@ilya.chernikov I tried to trim down that example and stumbled upon a different error (1.3.41):

// ~/t/a.kts
fun hello() = "hello"
hello()

and

$ kotlinc -script ~/t/a.kts
exception: java.lang.ArrayIndexOutOfBoundsException: Index 10912 out of bounds for length 10912
	at org.jetbrains.org.objectweb.asm.ClassReader.readUnsignedShort(ClassReader.java:2464)

Is it possible to configure script dependencies using package (with wildcard) instead of jar name ? (I don't have the jar name because of the build system I am using [bazel])

Can we make concurrent calls to BasicScriptingHost#eval ? Or should I create a host for each thread ?

Does kotlin-main-kts support Maven repos? resolve maven

@DependsOn

or is it still Ivy for now? Like can we add maven repositories with the repo annotation?

When an extension function is defined outside of any class, script evaluation is not resolving it e.g. class X() operator fun X.plus(x:X) = 1 I cannot get + or plus to be resolved from within a script, but when I put the method in the class like class X () { operator fun plus( x: X) = 1 } then X() + X() works although a fully qualified X().packagename.plus( X()) cannot resolve 'plus' Im guessing this has to do with how extension functions are named and imported -- but I havent found the 'trick' to import them. Any suggestions ?

I am trying to get IDE support for my script but I get this error : https://pastebin.com/SdHtVmCD

Hopefully last questions for this week: is it possible to create an IntelliJ plugin that restricts the suggestions ? (I want to remove all suggestions coming from the stdlib). Also is it possible to easily create a plugin instead of relying on host discovery that doesn't seem to always work ? (especially once we add compilation configuration, etc)

I was not touching my scripting example for some time and not (probably after version upgrade I get

Expecting 'hostConfiguration' property in the script compilation configuration for the script KtFile: script.kts

I tried to somehow provide this

hostConfiguration

, but I just do not understand how it works. My configuration looks like this:

val workspaceScriptConfiguration = ScriptCompilationConfiguration {
            baseClass(Any::class)
            implicitReceivers(WorkspaceBuilder::class)
            defaultImports("hep.dataforge.workspace.*")
            jvm {
                dependenciesFromCurrentContext(wholeClasspath = true)
            }
        }

        val evaluationConfiguration = ScriptEvaluationConfiguration {
            implicitReceivers(builder)
        }

        BasicJvmScriptingHost().eval(source, workspaceScriptConfiguration, evaluationConfiguration)

Any reason why kotlin-scripting-jvm-host is the only scripting related JAR that is not shipped with the compiler release ? (https://github.com/JetBrains/kotlin/releases/tag/v1.3.41). Also, is there an official release for this JAR ? (I know it is available in maven central but I need an "official" release link, if there is any)

I have strange script problem. I use

implicitReceivers()

and trying to import another script using

@file:Import("..")

annotation. In

evalWithConfigAndOtherScriptsResults()

-- it's part of

kotlin.script.experimental.jvm.BasicJvmScriptEvaluator

there is next code:

val ctor = java.constructors.single() // <-- generated constructor which expects (imported script result, implicit receiver)
val instance = ctor.newInstance(*args.toArray()) // <--- args here reversed, so (implicit receiver, imported script result)

did somebody meet this problem?

Seems

kotlin-scripting-jvm-host

is missing a dependency on

kotlin-scripting-compiler(-embeddable)

in the pom. Had to explicitly specify it.

How do I run a standalone Kotlin script like the one shown in the examples here: https://github.com/Kotlin/KEEP/blob/master/proposals/scripting-support.md ? I'm writing

kotlinc -cp kts.jar -script test.kts

, where

test.kts

is my script file and

kts.jar

is the

kotlin-main-kts

JAR from Maven, but I get 'Unable to find script definitions' and a bunch of errors related to it not knowing what the dependency annotations are. I'm following the tutorial as exactly as I understand it - what's missing?

Follow up question: if the standard/most common way of running

.kts

files will be with this script runner, why is it not default? The complexity of use is keeping scripting from becoming widely useful. I'd like the equivalent

python script.py

, and I'd like it to be part of installing Kotlin. Until it's that simple, I can't rely on distributing

.kts

files to others as a consistent, portable, easy way of giving other people scripts. I know

kscript

exists, but it only supports *nix.

I could put together a temporary solution with these features: - Maven dependency resolution via future-standard

@Repository

and such, possibly with Maven Central and JCenter just implied - future-compatible support with normal Kotlin scripts top priority - Interactive mode - load the KT/KTS file and then get a REPL - Line Argument - run the KT/KTS file, providing the expression you wish to be executed in that context. - Open in IntelliJ - creates a project in a temp folder, including needed files using hard links. Full auto-complete. Does not use Gradle under the hood, but rather direct IML files. - Fully platform independent, running in Java without any platform-specific features nor a separate installation of Kotlin (use embedded compiler instead) - Perhaps platform-specific GUI integration - double click on script file to run, context-menu edit... Is this something people would be interested in? I think it wouldn't take me too long - I've experimented with similar things already. I already know how to create IntelliJ projects from XML, running Kotlin scripts, running the embedded Kotlin compiler, etc. I'd primarily use it for build-scripts, personally. It would be nice to ditch Gradle and anything Gradle-like in favor of straight-up using libraries from Maven to compile your stuff. That would be some nice standard reuse there. I can imagine creating a

build.kts

file and then opening it in interactive mode in the terminal of IntelliJ to run tasks like

build()

,

run()

,

publish()

, etc. It would be so much faster to edit (Gradle's KTS editing isn't too speedy and resolving plugins can be tricky) and would make build files easier to follow, as they'd just be more normal Kotlin without extra bulky configuration systems and magic plugins. No build system, just... Kotlin. I'd have to make a couple of Maven libraries to make it more convenient to set up, but that's not too bad.

Give me until the end of Saturday! I already have most of the parts working; I'm now working on platform-specific GUI integration (installation, more or less) and then tying it all together in one main function. I'll distribute it as a fat JAR. I wasn't kidding when I said I've been experimenting with stuff already! The IDE stuff was the most troublesome to experiment with (I was working on that earlier this week, wanted to know how IMLs worked) because I couldn't find any documentation on the format of it. I had to kinda just guess my way through it.

UX question: should the default action (double click) be to edit a script or run it?

@tateisu re scripting on android. Great question ! No Answer 😞 Ignorant Guess: Maybe -- if you dont use the JSR232 interface ?? (just the native one). Ignorant count-guess: No idea if even the embeded scripting compiler will run on android

Project Skate, my experimental scripting-oriented project with Kotlin, is available as stated above. https://github.com/UnknownJoe796/skate I still recommend KScript if you're not on Windows, but learning from this has been well worth my time. Hopefully there are some things that could be pulled out into KScript and perhaps other projects. There's several well-separated modules in here for making IntelliJ projects, compiling Kotlin, and resolving Maven dependencies. I couldn't get

.kts

proper files working - for whatever reason, the embedded compiler wouldn't compile them but the standalone one would. Also couldn't figure out how to get them playing well with plain IntelliJ projects. I'd love to learn more about the topic if anyone has information I couldn't find.

Hi, I have some issues with executing scripts from our kotlin code. 1. Script evaluating consumes a lot of memory, we evaluate around 100 scripts and and it consumes about 2G of memory. Before 1.3.50 we noticed that if we use engine #compile, after that #eval(bindings) and after that we clear the bindings the memory consumption has been reduced to 700M (Not ideal but something). After upgrading to 1.3.50 this work-around does not work anymore. 2. I thought that using ‘kotlin-main-kts’ might reduce memory consumption, but I can not get it working with bindings. It works with executing simple scripts but not with using bindings ( or external params through engine.put(,)) I’d appreciate any any help, guys. Thanks in advance.

Hey! i'm currently working on a server, where i need to be able to configure rather complicated actions. I've currently built a proof of concept DSL for that, and it's great. But i need to be able to reconfigure it without having to restart / recompile my server, so just putting the DSL into the server is no option. I thought about using Kotlin-script for that purpose. I'd need to somehow expose my DSL api to kotlin-script, evaluate that script from my Kotlin-server and get the configuration back. is this currently possible, or say practical with Kotlinscript? there are two questions: - how can i get my type-safe DSL API into kotlinscript? - how could i get the generated objects back from the script? any help would be appreciated ;D

Just tried the evaluation via "kotlin-scripting-jsr223" (1.3.50) and found out that trying to call a binding named e.g. "example" from within a coroutine (I presume it's about everything accepting a suspending lambda) throws NoSuchMethodError with a message like:

Exception in thread "..." java.lang.NoSuchMethodError: Line_1.access$getExample$p(LLine_1;)Ljava/lang/String;

Surprised this wasn't reported already - is everyone affected? https://youtrack.jetbrains.com/issue/KT-33636

Request Reference to 'Current' Working self-contained sample of basic JVM Scripting Host build I have tried, unsuccessfully, many times over the last 2 years to put together a very 'basic' JVM Scripting 'host' that can do a 'Eval' of a .kts file or script body (and parameters). I was able to get the JSR223 samples to work (which I have working now) but they are not ideal and have a lot of dependencies and resource use which I've learned recently (From this list) that are not issues with the native scripting host. The problem I find is that I cannot locate a 'current working example' anywhere -- Ive found many that probably worked at some time but by the time I find them them they do not, Or examples , such as from the intellij and kotlin distributions that might work -- -- if only I could decipher the chain of dependencies in the whole project -- And many of those simply didnt work even when built directly within the project cleanly cloned from github. I know its a moving target, and that dependencies are either not shipped or expected to be replaced by others or 'internal only' or some other combination of magic - all for good reasons. Or that the code-in-question 'Works For Me' where 'Me' is an internal developer or someone with a dependency resolver that I cannot locate or reverse engineer. At this point in the 'Kotlin Scripting Story' surely theirs a basic stable example to use ? Probably LOTS -- but which one is valid right now ? Any suggestions welcome. (And yes I've RTFM's every article, blog, KEEP, reference etc I can find -- without locating this magic bean)

Bare minimal self-contained kotlin program that evaluates kotlin script using 'current' gradle/kotlin/intellij Thanks to @Egor for patience Note: This is NOT an example of 'best practice' -- I dont know what that is, its an example of "I Finally got the non-223 script host to compile and run" https://github.com/DALDEI/kotlin-script-sample

on the way home today i was thinking about.. how does the embedded compiler integrate with eg. compile plugins ? i assume using kotlinx-serialization would work since its bundled in the normal compiler, but does it have to be enabled? (never tried) and what about potential 3rd party plugins?

Can I configure an annotation processor in kscript somehow?

Hi guys! I have a question about changing the definition of a class/jar used by my scripts. I have a server that takes code (a String) as input, compiles/evaluates the code and returns some result. To do that I instantiate a BasicJvmScriptingHost that is shared between requests (code of the script host is more or less https://pastebin.com/gtPvPaT1). Scripts are allowed to depend on some JARs, and one of those JARs contains a single generated class whose definition will change during the server lifetime. Is it possible to make my scripts depend on the latest definition of this JAR without needing to restart my server or recreating a host ? If necessary this generated class could also be contained in a Kotlin Script that we would make accessible to the other scripts (if it's possible). Thanks 🙂

Hello, We’re in the process of migrating the Gradle Kotlin DSL from the legacy Kotlin script API to the latest experimental one so we can take advantage of the new implicit receivers feature but I’m having a little trouble figuring out how to migrate one of our script templates. In the troublesome scenario the list of default imports must be computed dynamically from data passed from the outside to the compiler. With the legacy API we were able to achieve it via a custom

ScriptDependenciesResolver

that reads the data from the given script resolver environment which can be configured via the

-Xscript-resolver-environment

command line argument. The custom resolver is setup via the

ScriptTemplateDefinition

annotation: https://github.com/gradle/gradle/blob/6f683805c6b782b1eb91c01591aecabe6fe535fb/subprojects/kotlin-dsl/src/main/kotlin/org/gradle/kotlin/dsl/precompile/PrecompiledProjectScript.kt#L52-L54 My understanding is that it is NOT possible to mix the legacy

ScriptTemplateDefinition

annotation with the new

KotlinScript

one to get both, the dynamic implicit imports computed from the script resolver environment plus the implicit receivers from a custom

compilationConfiguration

setup. So the question is then, does the experimental API allow for the list of default imports for a given script to be computed based on command line arguments passed to the compiler?

@KotlinScript(
        compilationConfiguration = DynamicDefaultImportsConfiguration::class
        // other settings
    )
    open class ScriptWithDynamicDefaultImports

    object DynamicDefaultImportsConfiguration : ScriptCompilationConfiguration({
        refineConfiguration {
            beforeCompiling {
                it.compilationConfiguration.with {
                    defaultImports(
                        // How to read arguments passed to the compiler from here?
                        TODO()
                    )
                }.asSuccess()
            }
        }
    })