Added tests for local jar files.

Signed-off-by: Marcin Kuszczak <1508798+aartiPl@users.noreply.github.com>

Author: aartiPl

NEWS.md

@@ -17,13 +17,13 @@
 * Improved implementation: VersionChecker, ConfigBuilder etc.
 * Updated Gradle and dependencies
 * Deprecated @file:Include in favour of @file:Import as a preparation of switch to Kotlin Scripting
-* Get rid of docopt handler from KscriptHandler (helps with using kscript as library)
+* Replaced DocOpt with Apache CLI
 * Changed the way of creating distribution package - now it is handled by Gradle
 * Version of kscript is set by Gradle (generated BuildConfig class)
 * Improved DependencyResolver: aar archives are also included in classpath
 * When creating IntelliJ project Gradle and Idea are no more required
-* Ability to provide local artifacts path through KSCRIPT_DIRECTORY_ARTIFACTS or configuration file property:
-  scripting.directory.artifacts (thanks to [Vsajip](https://github.com/vsajip) for initial implementation)
+* Ability to provide local artifacts path through **KSCRIPT_DIRECTORY_ARTIFACTS** or configuration file property:
+  **scripting.directory.artifacts** (thanks to [Vsajip](https://github.com/vsajip) for initial implementation)
 
 **Bugfixes**
 

README.md

@@ -40,7 +40,7 @@ kotlin scripting interpreter.
 - [Script Configuration](#script-configuration)
 - [Text Processing Mode](#text-processing-mode)
 - [Treat yourself a REPL with `--interactive`](#treat-yourself-a-repl-with---interactive)
-- [Boostrap IDEA from a `kscript`let](#boostrap-idea-from-a-kscriptlet)
+- [Boostrap IDEA from a scriptlet](#boostrap-idea-from-a-scriptlet)
 - [Deploy scripts as standalone binaries](#deploy-scripts-as-standalone-binaries)
 - [Embed kscript installer within your script](#embed-kscript-installer-within-your-script)
 - [KScript configuration file](#kscript-configuration-file)
@@ -105,7 +105,8 @@ instance [bind mounts](https://docs.docker.com/storage/bind-mounts/).
 #### Installation without `sdkman`
 
 If you have Kotlin already, and you would like to install the latest `kscript` release without using `sdkman`
-you can do so by unzipping the [latest ](https://github.com/holgerbrandl/kscript/releases/latest) binary release. Don't forget to update your `$PATH` accordingly.
+you can do so by unzipping the [latest ](https://github.com/holgerbrandl/kscript/releases/latest) binary release. Don't
+forget to update your `$PATH` accordingly.
 
 #### Installation with Homebrew
 
@@ -132,6 +133,23 @@ favorite [AUR helper](https://wiki.archlinux.org/index.php/AUR_helpers) to insta
 yay -S kscript
 ```
 
+There is an uncommon directory layout of Kotlin package for Arch Linux, which causes problems when using kscript with
+default Kotlin package.
+Two workarounds for ArchLinux exists, which can be used to make 'kscript' working with ArchLinux:
+
+1. Manually create symlinks in the system:
+
+    ```shell
+    sudo mkdir /usr/share/kotlin/bin
+    sudo ln -s /usr/bin/kotlin /usr/share/kotlin/bin/kotlin   
+    sudo ln -s /usr/bin/kotlinc /usr/share/kotlin/bin/kotlinc
+    ```
+2. Install Kotlin using SdkMan:
+   [Installation of SdkMan](#installation)
+
+The problem should be fixed in the Kotlin package for ArchLinux. See more in the Github issue:  
+https://github.com/kscripting/kscript/issues/371
+
 #### Build it yourself
 
 To build `kscript` yourself, simply clone the repo and do
@@ -279,12 +297,14 @@ println("Hello from Kotlin!")
 println("Parsed script arguments are: \n" + doArgs)
 ```
 
-`kscript` will read dependencies from all lines in a script that start with `@file:DependsOn` (if any). Multiple dependencies can
+`kscript` will read dependencies from all lines in a script that start with `@file:DependsOn` (if any). Multiple
+dependencies can
 be split by comma, space or semicolon.
 
 ### Configure the runtime  with `@file:KotlinOptions`
 
-`kscript` allows to provide a `@file:KotlinOptions` directive followed by parameters passed on to `kotlin` similar to how
+`kscript` allows to provide a `@file:KotlinOptions` directive followed by parameters passed on to `kotlin` similar to
+how
 dependencies are defined:
 
 ```kotlin
@@ -298,7 +318,8 @@ Note: Similar to the runtime you can also tweak the compile step by providing `@
 
 ### Ease prototyping with `@file:Import`
 
-`kscript` supports an `@file:Import` directive to directly include other source files without prior compilation. Absolute
+`kscript` supports an `@file:Import` directive to directly include other source files without prior compilation.
+Absolute
 and relative paths, as well as URLs are supported. Example:
 
 ```kotlin
@@ -359,7 +380,7 @@ The latter is the default for `kt` files and could be omitted
 #!/usr/bin/env kscript
 
 // Declare dependencies
-@file:DependsOn("com.github.holgerbrandl:kutils:0.12") 
+@file:DependsOn("com.github.holgerbrandl:kutils:0.12")
 @file:DependsOn("com.beust:klaxon:0.24", "com.github.kittinunf.fuel:fuel:2.3.1")
 
 // To use a custom maven repository you can declare it with
@@ -380,8 +401,8 @@ The latter is the default for `kt` files and could be omitted
 @file:Import("util.kt")
 
 // Define kotlin options
-@file:KotlinOptions("-J-Xmx5g") 
-@file:KotlinOptions("-J-server") 
+@file:KotlinOptions("-J-Xmx5g")
+@file:KotlinOptions("-J-server")
 @file:CompilerOptions("-jvm-target 1.8")
 
 // declare application entry point (applies on for kt-files)
@@ -472,7 +493,7 @@ Welcome to Kotlin version 1.1.51 (JRE 1.8.0_151-b12)
 >>> 
 ```
 
-Boostrap IDEA from a `kscript`let
+Boostrap IDEA from a scriptlet
 -----------------------------------
 
 Artifacts and versions will differ between scripts, so it is hard to maintain them all in a single project. To
@@ -483,14 +504,14 @@ for `<script>` arguments.
 kscript --idea CountRecords.kts
 ```
 
-If you have available `gradle` in the path project will be automatically built and if there is `idea` in the path 
-the project will be opened in [IntelliJ IDEA](https://www.jetbrains.com/idea/) with a minimalistic project containing 
+If you have available `gradle` in the path project will be automatically built and if there is `idea` in the path
+the project will be opened in [IntelliJ IDEA](https://www.jetbrains.com/idea/) with a minimalistic project containing
 just your (1) `<script>` and (2) a generated `build.gradle.kts` file:
 
 ![](misc/readme_images/minus_idea.png)
 
-The `idea` command line launcher can can be created in IntelliJ with `Create Command-line Launcher` command, or you can 
-set the command used to launch your IntelliJ as `KSCRIPT_COMMAND_IDEA` env property. Similarly, you can set `gradle` 
+The `idea` command line launcher can can be created in IntelliJ with `Create Command-line Launcher` command, or you can
+set the command used to launch your IntelliJ as `KSCRIPT_COMMAND_IDEA` env property. Similarly, you can set `gradle`
 command using `KSCRIPT_COMMAND_GRADLE` env property.
 
 Deploy scripts as standalone binaries
@@ -523,7 +544,7 @@ the [Installation](#installation) steps first.
 
 Note that unlike the [`--package` option](#deploy-scripts-as-standalone-binaries) this doesn't produce a separate file,
 allowing the distributed script to be read and modified(including
-with [`kscript --idea`](#boostrap-idea-from-a-kscriptlet)) similar to what you might expect with bash/python/ruby
+with [`kscript --idea`](#boostrap-idea-from-a-scriptlet)) similar to what you might expect with bash/python/ruby
 scripts.
 On the other hand this doesn't embed dependencies within the script("fat jar"), so internet connection may be required
 on its first run.
@@ -533,14 +554,17 @@ kscript configuration file
 
 To keep some options stored permanently in configuration you can create kscript configuration file.
 
-KScript follows XDG directory standard, so the file should be created in:
-
+KScript follows XDG directory standard, so the file should be created in (paths are resolved in provided order; first
+existing path is used):
 
-| OS          | PATH                                                                                |
-|-------------|-------------------------------------------------------------------------------------|
-| **Windows** | %LOCALAPPDATA%\kscript.properties                                                   |
-| **Posix**   | \\${XDG_CONFIG_DIR}/kscript.properties or \\${user.home}/.config/kscript.properties |
+| OS          | PATH                                                                                              |
+|-------------|---------------------------------------------------------------------------------------------------|
+| **Windows** | %LOCALAPPDATA%\kscript\kscript.properties; %USERPROFILE%\.config\kscript\kscript.properties       |
+| **MacOs**   | ~/Library/Application Support/kscript/kscript.properties;                                         |
+| **Posix**   | \\${XDG_CONFIG_DIR}/kscript/kscript.properties; \\${user.home}/.config/kscript/kscript.properties |
 
+If the environment variable: **KSCRIPT_DIRECTORY** is defined the configuration file 'kscript.properties' will be placed
+directly inside it.
 
 Content of kscript.properties file is a standard Java format, with following properties available:
 
@@ -550,6 +574,7 @@ scripting.kotlin.opts=
 scripting.repository.url=
 scripting.repository.user=
 scripting.repository.password=
+scripting.directory.artifacts=
 ```
 
 Example configuration file:
@@ -594,11 +619,12 @@ is a valid Kotlin `kts` script. Plain and simple, no `main`, no `companion`, jus
 
 ### Does `kscript` also work for regular kotlin `.kt` source files with a `main` as entry point?
 
-Yes, (since kscript v1.6) you can run kotlin source files through `kscript`. By default, it will assume a top-level `main` method
+Yes, (since kscript v1.6) you can run kotlin source files through `kscript`. By default, it will assume a
+top-level `main` method
 as entry-point.
 
-However, in case you're using a companion object to declare the entry point, you need to indicate this via the `@file:Entry`.
-
+However, in case you're using a companion object to declare the entry point, you need to indicate this via
+the `@file:Entry`.
 
 ### What are performance and resource usage difference between scripting with kotlin and python?
 

TODO.md

@@ -1,11 +1,10 @@
 # kscript 4.2 features:
 
 * Release kscript to Maven Central
-* Change a way of executing .kts files (investigate if we can get rid of reflections)
-* Fix the bug on ArchLinux
-* Onboard on brew
 * Test local artifacts directory
 
+* Change a way of executing .kts files (investigate if we can get rid of reflections)
+* Onboard on brew
 * Deprecate KotlinOptions
 * New package for Windows e.g. scoop
 * Release scripts in Kotlin

src/integration/kotlin/io/github/kscripting/kscript/integration/KtSupportTest.kt

@@ -11,7 +11,7 @@ class KtSupportTest : TestBase {
     @Test
     @Tag("posix")
     fun `Run kt via interpreter mode`() {
-        verify(resolvePath("$projectDir/test/resources/kt_tests/simple_app.kt"), 0, "main was called\n", any())
+        verify(resolvePath("$projectDir/test/resources/kt_tests/simple_app.kt").stringPath(), 0, "main was called\n", any())
     }
 
     @Test
@@ -43,6 +43,6 @@ class KtSupportTest : TestBase {
     @Test
     @Tag("posix")
     fun `Also make sure that kts in package can be run via kscript`() {
-        verify(resolvePath("$projectDir/test/resources/script_in_pckg.kts"), 0, "I live in a package!\n", any())
+        verify(resolvePath("$projectDir/test/resources/script_in_pckg.kts").stringPath(), 0, "I live in a package!\n", any())
     }
 }

src/integration/kotlin/io/github/kscripting/kscript/integration/MiscTest.kt

@@ -4,6 +4,7 @@ import io.github.kscripting.kscript.integration.tools.TestAssertion.any
 import io.github.kscripting.kscript.integration.tools.TestAssertion.contains
 import io.github.kscripting.kscript.integration.tools.TestAssertion.verify
 import io.github.kscripting.kscript.integration.tools.TestContext.projectDir
+import io.github.kscripting.kscript.integration.tools.TestContext.resolvePath
 import io.github.kscripting.kscript.integration.tools.TestContext.testDir
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
@@ -31,7 +32,11 @@ class MiscTest : TestBase {
     @Tag("windows")
     fun `Prevent regressions of #98 (it fails to process empty or space-containing arguments)`() {
         verify("""kscript "print(args.size)" foo bar""", 0, "2") //regular args
-        verify("""kscript "print(args.size)" "--params foo"""", 0, "1") //make sure dash args are not confused with options
+        verify(
+            """kscript "print(args.size)" "--params foo"""",
+            0,
+            "1"
+        ) //make sure dash args are not confused with options
         verify("""kscript "print(args.size)" "foo bar"""", 0, "1") //allow for spaces
     }
 
@@ -77,4 +82,17 @@ class MiscTest : TestBase {
         //real test
         verify("kscript $projectDir/test/resources/invalid_script.kts", 1, "", contains("error: expecting ')'"))
     }
+
+    @Test
+    @Tag("posix")
+    @Tag("windows")
+    fun `Test local jar dir referenced in ENV variable`() {
+        val shellPath = resolvePath("$projectDir/test/resources/config/")
+        verify(
+            "KSCRIPT_DIRECTORY_ARTIFACTS=${shellPath.resolve("jarFiles")} kscript ${shellPath.resolve("script_with_local_jars.kts")}",
+            0,
+            "I am living in Test1 class...\nAnd I come from Test2 class...\n",
+            ""
+        )
+    }
 }

src/integration/kotlin/io/github/kscripting/kscript/integration/tools/TestContext.kt

@@ -33,8 +33,8 @@ object TestContext {
         testPath.createDirectories()
     }
 
-    fun resolvePath(path: String): String {
-        return OsPath.createOrThrow(osType, path).stringPath()
+    fun resolvePath(path: String): OsPath {
+        return OsPath.createOrThrow(osType, path)
     }
 
     fun runProcess(command: String): GobbledProcessResult {

src/main/kotlin/io/github/kscripting/kscript/KscriptHandler.kt

@@ -70,13 +70,13 @@ class KscriptHandler(
             warnMsg("There are deprecated features in scripts. Use --report option to print full report.")
         }
 
-        val localArtifacts = if (config.scriptingConfig.artifactsDir != null) {
-            getArtifactsRecursively(config.scriptingConfig.artifactsDir)
-        } else emptyList()
-
         val resolvedDependencies = cache.getOrCreateDependencies(script.digest) {
-            DependencyResolver(script.repositories).resolve(script.dependencies)
-        } + localArtifacts
+            val localArtifacts = if (config.scriptingConfig.artifactsDir != null) {
+                getArtifactsRecursively(config.scriptingConfig.artifactsDir)
+            } else emptyList()
+
+            DependencyResolver(script.repositories).resolve(script.dependencies) + localArtifacts
+        }
 
         //  Create temporary dev environment
         if (options.containsKey("idea")) {

src/main/kotlin/io/github/kscripting/kscript/model/ConfigBuilder.kt

@@ -63,7 +63,6 @@ class ConfigBuilder(
         val configFile: OsPath = configFile ?: kscriptDir?.resolve("kscript.properties") ?: when {
             osType.isWindowsLike() -> environment.getEnvVariableOrNull("LOCALAPPDATA")?.toOsPathFromNative()
                 ?: userHomeDir.resolve(".config")
-
             osType == OsType.MACOS -> userHomeDir.resolve("Library", "Application Support")
             else -> environment.getEnvVariableOrNull("XDG_CONFIG_DIR")?.toOsPathFromNative()
                 ?: userHomeDir.resolve(".config")
@@ -110,7 +109,7 @@ class ConfigBuilder(
         ?: configProperties.getPropertyOrNull("scripting.repository.password") ?: ""
 
         val artifactsDir: OsPath? =
-            artifactsDir ?: environment.getEnvVariableOrNull("KSCRIPT_DIRECTORY_ARTIFACTS")?.toOsPathFromNative()
+            artifactsDir ?: environment.getEnvVariableOrNull("KSCRIPT_DIRECTORY_ARTIFACTS")?.toOsPathFromOsSpecific(osType)
             ?: configProperties.getPropertyOrNull("scripting.directory.artifacts")?.toOsPathFromOsSpecific(osType)
 
         val scriptingConfig = ScriptingConfig(

src/main/kotlin/io/github/kscripting/kscript/util/FileUtils.kt

@@ -59,7 +59,7 @@ object FileUtils {
     fun getArtifactsRecursively(osPath: OsPath): List<OsPath> {
         val artifacts = mutableListOf<OsPath>()
 
-        osPath.toNativeFile().walk().forEach {
+        osPath.toNativeFile().absoluteFile.walk().forEach {
             if (it.isFile && (it.extension == "jar" || it.extension == "aar")) {
                 artifacts.add(it.toOsPath())
             }

src/test/kotlin/io/github/kscripting/kscript/util/FileUtilsTest.kt

@@ -1,16 +1,22 @@
 package io.github.kscripting.kscript.util
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import io.github.kscripting.shell.model.OsPath
 import io.github.kscripting.shell.model.OsType
+import io.github.kscripting.shell.model.readText
 import io.github.kscripting.shell.model.toNativeFile
 import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import org.apache.commons.io.FileUtils as ApacheFileUtils
 
-@Disabled
 class FileUtilsTest {
     private val path = OsPath.createOrThrow(OsType.native, "build/tmp/file_utils_test")
+    private val newFile1 = path.resolve("test1.txt")
+    private val newFile2 = path.resolve("test2.txt")
+    private val newFile3 = path.resolve("firstDir", "secondDir", "test3.txt")
+    private val newFile4 = path.resolve("dir1", "dir2", "test4.txt")
+    private val content1 = "Test\nContent\n"
 
     @BeforeEach
     fun setUp() {
@@ -19,18 +25,32 @@ class FileUtilsTest {
 
     @Test
     fun `Test create file`() {
-        FileUtils.createFile(path.resolve("test1"), "Test")
+        FileUtils.createFile(newFile1, content1)
+        assertThat(newFile1.readText()).isEqualTo(content1)
     }
 
     @Test
     fun `Test symlink file`() {
-        FileUtils.createFile(path.resolve("test1"), "Test")
-        FileUtils.symLinkOrCopy(path.resolve("test2"), path.resolve("test1"))
+        FileUtils.createFile(newFile1, content1)
+        FileUtils.symLinkOrCopy(newFile2, newFile1)
+
+        assertThat(newFile2.readText()).isEqualTo(content1)
     }
 
     @Test
     fun `Create dirs if needed`() {
-        FileUtils.createFile(path.resolve("test1"), "Test")
-        FileUtils.symLinkOrCopy(path.resolve("test2"), path.resolve("test1"))
+        FileUtils.createFile(newFile3, content1)
+        FileUtils.symLinkOrCopy(newFile4, newFile3)
+
+        assertThat(newFile4.readText()).isEqualTo(content1)
+    }
+
+    @Test
+    fun `Assert that getArtifactsRecursively finds all the artifacts in the path`() {
+        val artifactsPath = OsPath.createOrThrow(OsType.native, "test/resources/config/jarfiles/")
+
+        assertThat(FileUtils.getArtifactsRecursively(artifactsPath)).transform {
+            it.map { it.stringPath().substringAfterLast("jarfiles").replace("\\", "/") }
+        }.isEqualTo(listOf("/jar_file_1.jar", "/subdir/jar_file_2.jar"))
     }
 }