Replace toml config with a javascript file

README.md

@@ -12,8 +12,9 @@ Move the executable somewhere in your $PATH
 Or build a native image with GraalVM
 
 ```bash
-./gradlew buildNative
-cd app/build/native
+./gradlew installShadowDist
+cd app/build/install/app-shadow/lib
+native-image --no-fallback -R:MaxNewSize=32 --language:js -jar scaffold.jar
 ```
 
 ## Usage

app/build.gradle.kts

@@ -1,21 +1,24 @@
 plugins {
     id("kotlin-application")
-    id("shadow")
-    id("native-image")
-    id("release")
+    id("com.github.johnrengelman.shadow") version "6.1.0"
 }
 
-version = "0.0.1-SNAPSHOT"
-
 dependencies {
-    implementation("org.slf4j:slf4j-api:2.0.7")
-    runtimeOnly("org.slf4j:slf4j-simple:2.0.7")
-    implementation("io.pebbletemplates:pebble:3.2.1")
-    implementation("com.github.ajalt.clikt:clikt:3.5.2")
-    implementation("org.graalvm.js:js:22.3.2")
+    implementation("org.slf4j:slf4j-api:2.0.0-alpha1")
+    runtimeOnly("org.slf4j:slf4j-simple:2.0.0-alpha1")
+    implementation("io.pebbletemplates:pebble:3.1.5")
+    implementation("com.github.ajalt.clikt:clikt:3.1.0")
+    implementation("org.graalvm.js:js:21.0.0.2")
 }
 
 application {
+    mainClassName = "scaffold.ScaffoldKt"
     mainClass.set("scaffold.ScaffoldKt")
     applicationName = "scaffold"
 }
+
+tasks.withType<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar> {
+    archiveBaseName.set("scaffold")
+    archiveClassifier.set("")
+    archiveVersion.set("")
+}

app/resources/META-INF/native-image/reflect-config.json

@@ -1,4 +1,7 @@
 [
+{
+  "name":"com.electronwill.nightconfig.toml.TomlFormat"
+},
 {
   "name":"java.util.Map$Entry",
   "allPublicMethods":true

app/resources/init/index.d.ts

@@ -5,39 +5,42 @@
  */
 declare function echo(message: string): void
 
-declare interface prompt {
-
-    /**
+/**
  * Prompt a user for text input
  *
  * @param text - The text to display for the prompt
  * @param def - A default value
  */
-    string(text: string, def?: string): string
+declare function prompt(text: string, def?: string): string
 
-    /**
+/**
  * Prompt a user for text input
  *
  * @param text - The text to display for the prompt
  * @param def - A default value
  */
-    boolean(text: string, def?: boolean): boolean
-
-}
+declare function promptBoolean(text: string, def?: boolean): boolean
 
 /**
  * Renders a template
  *
  * @param name - The template name
  * @param context - The template context
- * @param output - The output path, if absent, default to the template name
  */
-declare function render(name: string, context: any, output?: string): string
+declare function render(name: string, context: any): string
+
+/**
+ * Write a string to a file
+ *
+ * @param input - The content of the file
+ * @param output - The output path
+ */
+declare function write(input: string, output: string): void
 
 /**
  * Copy a file
  *
  * @param input - The input path
- * @param output - The output path, if absent, default to the input path
+ * @param output - The output path
  */
-declare function copy(input: string, output?: string): void
+declare function copy(input: string, output: string): void

app/resources/init/index.js

@@ -1,7 +1,7 @@
 echo("Example")
 
-const name = prompt.string("Project name")
+const name = prompt("Project name")
 
 const ctx = {name: name}
 
-render("README.md", ctx)
+write(render("README.md", ctx), "README.md")

app/src/Prompt.kt

@@ -1,38 +0,0 @@
-package scaffold
-
-import com.github.ajalt.clikt.core.UsageError
-import com.github.ajalt.clikt.output.CliktConsole
-import com.github.ajalt.clikt.output.TermUi
-import com.github.ajalt.clikt.output.defaultCliktConsole
-
-@Suppress("DEPRECATION") // TODO: later..
-class Prompt(private val console: CliktConsole = defaultCliktConsole()) {
-
-    fun string(text: String, default: String?): String = TermUi.prompt(
-        text = text,
-        default = default,
-        console = console
-    ) { it }!!
-
-    fun boolean(text: String, default: Boolean?): Boolean {
-        val (defaultString, suffix) = when (default) {
-            true -> "y" to "[Y/n]"
-            false -> "n" to "[y/N]"
-            null -> null to "[y/n]"
-        }
-
-        return TermUi.prompt(
-            "$text $suffix",
-            default = defaultString,
-            showDefault = false,
-            console = console
-        ) {
-            when (it.lowercase()) {
-                "y" -> true
-                "n" -> false
-                else -> throw UsageError("Can only be [y/n]")
-            }
-        }!!
-    }
-
-}

app/src/commands/GenerateCommand.kt

@@ -2,16 +2,17 @@ package scaffold.commands
 
 import com.github.ajalt.clikt.core.CliktCommand
 import com.github.ajalt.clikt.core.ProgramResult
+import com.github.ajalt.clikt.core.UsageError
+import com.github.ajalt.clikt.output.TermUi
 import com.github.ajalt.clikt.parameters.arguments.argument
 import com.github.ajalt.clikt.parameters.options.convert
 import com.github.ajalt.clikt.parameters.options.option
 import com.github.ajalt.clikt.parameters.options.required
-import io.pebbletemplates.pebble.PebbleEngine
-import io.pebbletemplates.pebble.loader.FileLoader
-import io.pebbletemplates.pebble.template.PebbleTemplate
+import com.mitchellbosecke.pebble.PebbleEngine
+import com.mitchellbosecke.pebble.loader.FileLoader
+import com.mitchellbosecke.pebble.template.PebbleTemplate
 import scaffold.Generator
 import scaffold.Generators
-import scaffold.Prompt
 import scaffold.scripting.ScriptContext
 import scaffold.scripting.ScriptEngine
 import java.io.StringWriter
@@ -36,18 +37,39 @@ class GenerateCommand(private val generators: Generators) : CliktCommand("genera
         val scriptContext = object : ScriptContext {
             override fun echo(message: String) = this@GenerateCommand.echo(message)
 
-            override val prompt = Prompt()
+            override fun prompt(text: String, default: String?) = this@GenerateCommand.prompt(text, default)!!
 
-            override fun render(template: String, ctx: Map<String, Any?>, output: String?) {
-                val renderedTemplate = pebble.getTemplate(template)(ctx)
-                val outputPath = output?.let { outputPathRoot.resolve(it) } ?: outputPathRoot.resolve(template)
-                Files.createDirectories(outputPath.parent)
-                Files.writeString(outputPath, renderedTemplate)
+            override fun promptBoolean(text: String, default: Boolean?): Boolean {
+                val suffix = when (default) {
+                    true -> "[Y/n]"
+                    false -> "[y/N]"
+                    null -> "[y/n]"
                 }
 
-            override fun copy(input: String, output: String?) {
+                return this@GenerateCommand.prompt("$text $suffix", default = "$default", showDefault = false) {
+                    when (it.toLowerCase()) {
+                        "y" -> true
+                        "n" -> false
+                        else -> throw UsageError("Can only be [y/n]")
+                    }
+                }!!
+            }
+
+            override fun promptInt(text: String, default: Int?): Int {
+                TODO("Not yet implemented")
+            }
+
+            override fun render(name: String, ctx: Map<String, Any?>) = pebble.getTemplate(name)(ctx)
+
+            override fun write(content: String, output: String) {
+                val outputPath = outputPathRoot.resolve(output)
+                Files.createDirectories(outputPath.parent)
+                Files.writeString(outputPath, content)
+            }
+
+            override fun copy(input: String, output: String) {
                 val inputPath = generator.treeRoot.resolve(input)
-                val outputPath = output?.let { outputPathRoot.resolve(it) } ?: outputPathRoot.resolve(input)
+                val outputPath = outputPathRoot.resolve(output)
                 Files.createDirectories(outputPath.parent)
                 Files.copy(inputPath, outputPath)
             }

app/src/scripting/PromptProxyAdapter.kt

@@ -1,26 +0,0 @@
-package scaffold.scripting
-
-import org.graalvm.polyglot.Value
-import org.graalvm.polyglot.proxy.ProxyExecutable
-import org.graalvm.polyglot.proxy.ProxyObject
-import scaffold.Prompt
-
-class PromptProxyAdapter(private val prompt: Prompt) : ProxyObject {
-
-    override fun getMember(key: String?) = when (key) {
-        "string" -> ProxyExecutable { args ->
-            prompt.string(args[0].asString(), args.getOrNull(1)?.asString())
-        }
-        "boolean" -> ProxyExecutable { args ->
-            prompt.boolean(args[0].asString(), args.getOrNull(1)?.asBoolean())
-        }
-        else -> throw UnsupportedOperationException()
-    }
-
-    override fun getMemberKeys() = arrayOf("string", "boolean")
-
-    override fun hasMember(key: String?): Boolean = key in memberKeys
-
-    override fun putMember(key: String?, value: Value?) = throw UnsupportedOperationException()
-
-}

app/src/scripting/ScriptContext.kt

@@ -1,13 +1,14 @@
 package scaffold.scripting
 
-import scaffold.Prompt
-
 interface ScriptContext {
     fun echo(message: String)
 
-    val prompt: Prompt
+    fun prompt(text: String, default: String?): String
+    fun promptBoolean(text: String, default: Boolean?): Boolean
+    fun promptInt(text: String, default: Int?): Int
 
-    fun render(template: String, ctx: Map<String, Any?>, output: String?)
+    fun render(name: String, ctx: Map<String, Any?>): String
 
-    fun copy(input: String, output: String?)
+    fun write(content: String, output: String)
+    fun copy(input: String, output: String)
 }

app/src/scripting/ScriptEngine.kt

@@ -13,24 +13,34 @@ class ScriptEngine(private val scriptContext: ScriptContext) {
 
     init {
         with(context.getBindings("js")) {
-            putMember("echo", ProxyExecutable { (message) ->
-                scriptContext.echo(message.asString())
+            putMember("echo", ProxyExecutable { args ->
+                scriptContext.echo(args[0].asString())
                 null
             })
 
-            putMember("prompt", PromptProxyAdapter(scriptContext.prompt))
+            putMember("prompt", ProxyExecutable { args ->
+                scriptContext.prompt(args[0].asString(), args.getOrNull(1)?.asString())
+            })
+
+            putMember("promptBoolean", ProxyExecutable { args ->
+                scriptContext.promptBoolean(args[0].asString(), args.getOrNull(1)?.asBoolean())
+            })
+
+            putMember("promptInt", ProxyExecutable { args ->
+                scriptContext.promptInt(args[0].asString(), args.getOrNull(1)?.asInt())
+            })
 
             putMember("render", ProxyExecutable { args ->
                 @Suppress("UNCHECKED_CAST")
-                scriptContext.render(
-                    args[0].asString(),
-                    args[1].`as`(Map::class.java) as Map<String, Any?>,
-                    args.getOrNull(2)?.asString()
-                )
+                scriptContext.render(args[0].asString(), args[1].`as`(Map::class.java) as Map<String, Any?>)
             })
 
-            putMember("copy", ProxyExecutable { args ->
-                scriptContext.copy(args[0].asString(), args.getOrNull(1)?.asString())
+            putMember("write", ProxyExecutable { (input, output) ->
+                scriptContext.write(input.asString(), output.asString())
+            })
+
+            putMember("copy", ProxyExecutable { (input, output) ->
+                scriptContext.copy(input.asString(), output.asString())
             })
         }
     }

app/test/PromptTest.kt

@@ -1,60 +0,0 @@
-@file:Suppress("MemberVisibilityCanBePrivate")
-
-package scaffold
-
-import com.github.ajalt.clikt.output.CliktConsole
-import io.mockk.clearMocks
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.verify
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.TestInstance
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.CsvSource
-import strikt.api.expectThat
-import strikt.assertions.isEqualTo
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class PromptTest {
-
-    val console = mockk<CliktConsole>()
-    val prompt = Prompt(console)
-
-    @BeforeEach
-    fun beforeEach() = clearMocks(console)
-
-    @CsvSource(
-        value = [
-            "null, answer, answer",
-            "def, answer, answer",
-            "def, '', def"
-        ]
-    )
-    @ParameterizedTest(name = "prompt string({argumentsWithNames})")
-    fun `prompt string`(default: String?, answer: String, expectedValue: String) {
-        every { console.promptForLine(any(), any()) } returns answer
-        expectThat(prompt.string("test", default)).isEqualTo(expectedValue)
-    }
-
-    @CsvSource(
-        value = [
-            "null, y, true",
-            "null, n, false",
-
-            "true, '', true",
-            "true, y, true",
-            "true, n, false",
-
-            "false, '', false",
-            "false, y, true",
-            "false, n, false",
-        ]
-    )
-    @ParameterizedTest(name = "prompt boolean({argumentsWithNames})")
-    fun `prompt boolean`(default: Boolean?, answer: String, expectedValue: Boolean) {
-        every { console.promptForLine(any(), any()) } returns answer
-        expectThat(prompt.boolean("test", default)).isEqualTo(expectedValue)
-    }
-
-}

app/test/scripting/ScriptEngineTest.kt

@@ -1,4 +1,4 @@
-@file:Suppress("MemberVisibilityCanBePrivate")
+@file:Suppress("MemberVisibilityCanBePrivate", "PackageDirectoryMismatch")
 
 package scaffold.scripting
 
@@ -10,15 +10,11 @@ import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.TestInstance.Lifecycle
-import scaffold.Prompt
 
 @TestInstance(Lifecycle.PER_CLASS)
 class ScriptEngineTest {
 
-    val scriptContext = mockk<ScriptContext>().also {
-        every { it.prompt } returns Prompt()
-    }
-
+    val scriptContext = mockk<ScriptContext>()
     val scriptEngine = ScriptEngine(scriptContext)
 
     @BeforeEach
@@ -36,7 +32,7 @@ class ScriptEngineTest {
 
     @Test
     fun render() {
-        every { scriptContext.render("test", match { it["something"] == "hello" }, null) } returns Unit
+        every { scriptContext.render("test", match { it["something"] == "hello" }) } returns "blah"
 
         val script = """
             const ctx = {
@@ -48,7 +44,27 @@ class ScriptEngineTest {
 
         scriptEngine.eval(script)
 
-        verify { scriptContext.render(any(), any(), any()) }
+        verify { scriptContext.render(any(), any()) }
+    }
+
+    @Test
+    fun prompt() {
+        every { scriptContext.prompt("a", null) } returns "a"
+
+        val script = "prompt('a')"
+        scriptEngine.eval(script)
+
+        verify { scriptContext.prompt(any(), null) }
+    }
+
+    @Test
+    fun promptWithDefault(){
+        every { scriptContext.prompt("a", "default") } returns "default"
+
+        val script = "prompt('a', 'default')"
+        scriptEngine.eval(script)
+
+        verify { scriptContext.prompt(any(), any()) }
     }
 
 }

buildSrc/build.gradle.kts

@@ -2,12 +2,15 @@ plugins {
     `kotlin-dsl`
 }
 
+kotlinDslPluginOptions {
+    experimentalWarning.set(false)
+}
+
 repositories {
     gradlePluginPortal()
 }
 
 dependencies {
-    implementation(platform("org.jetbrains.kotlin:kotlin-bom:1.8.21"))
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.21")
-    implementation("com.github.johnrengelman:shadow:8.1.1")
+    implementation(platform("org.jetbrains.kotlin:kotlin-bom:1.4.31"))
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.31")
 }

buildSrc/src/main/kotlin/java-convention.gradle.kts

@@ -7,9 +7,8 @@ repositories {
 }
 
 java {
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(19))
-    }
+    targetCompatibility = JavaVersion.toVersion(11)
+    sourceCompatibility = JavaVersion.toVersion(11)
 }
 
 tasks.withType<JavaCompile> {

buildSrc/src/main/kotlin/kotlin-convention.gradle.kts

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -20,10 +18,9 @@ tasks.withType<Test> {
 }
 
 tasks.withType<KotlinCompile> {
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_19)
-        javaParameters.set(true)
-        languageVersion.set(KotlinVersion.KOTLIN_2_0)
+    kotlinOptions {
+        jvmTarget = "11"
+        javaParameters = true
     }
 }
 

buildSrc/src/main/kotlin/native-image.gradle.kts

@@ -1,54 +0,0 @@
-import org.gradle.jvm.toolchain.JavaToolchainService;
-import java.io.ByteArrayOutputStream
-
-task("buildNative") {
-    dependsOn("installShadowDist")
-
-    outputs.file("${buildDir}/native/scaffold")
-
-    doLast {
-        val graalvmHome = project.extensions.findByType<JavaToolchainService>()?.launcherFor {
-            languageVersion.set(JavaLanguageVersion.of(19))
-            vendor.set(JvmVendorSpec.GRAAL_VM)
-        }
-            ?.orNull
-            ?.executablePath?.asFile?.toPath()?.parent?.parent?.toString()
-            ?: System.getenv("GRAALVM_HOME")
-            ?: error("GRAALVM_HOME is not set")
-
-        val out = ByteArrayOutputStream()
-
-        exec {
-            commandLine(
-                "${graalvmHome}/bin/gu",
-                "list",
-                "-v",
-            )
-            standardOutput = out
-        }
-
-        val installedComponents = out.toString().lines()
-            .filter { it.startsWith("ID") }
-            .map { it.substringAfter(':').trim() }
-
-        if ("native-image" !in installedComponents) {
-            throw GradleException("GRAALVM: Missing js component")
-        }
-
-        if ("js" !in installedComponents) {
-            throw GradleException("GRAALVM: Missing js component")
-        }
-
-        exec {
-            commandLine(
-                "${graalvmHome}/bin/native-image",
-                "--no-fallback",
-                "-R:MaxNewSize=32",
-                "--language:js",
-                "-jar",
-                "${buildDir}/install/app-shadow/lib/scaffold.jar",
-                "${buildDir}/native/scaffold"
-            )
-        }
-    }
-}

buildSrc/src/main/kotlin/release.gradle.kts

@@ -1,7 +0,0 @@
-tasks.register<Zip>("release") {
-    dependsOn("buildNative")
-    
-    archiveFileName.set("scaffold-${archiveVersion.get()}-linux.zip")
-    destinationDirectory.set(file("$buildDir/release"))
-    from("$buildDir/native/scaffold")
-}

buildSrc/src/main/kotlin/shadow.gradle.kts

@@ -1,11 +0,0 @@
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
-plugins {
-    id("com.github.johnrengelman.shadow")
-}
-
-tasks.withType<ShadowJar> {
-    archiveBaseName.set("scaffold")
-    archiveClassifier.set("")
-    archiveVersion.set("")
-}

gradle.properties

@@ -1,3 +0,0 @@
-org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8
-org.gradle.caching=true
-org.gradle.parallel=true

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
-networkTimeout=10000
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists