A simple picocli/native-image ion-java CLI

.editorconfig

@@ -0,0 +1,11 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace=true
+
+[{*.kt,*.kts}]
+ij_kotlin_imports_layout = *
+ij_kotlin_packages_to_use_import_on_demand=com.amazon.ion.**,java.util.*
+
+[src/test/**.kt]
+ktlint_ignore_back_ticked_identifier=true

.github/workflows/main.yml

@@ -3,10 +3,7 @@ permissions: read-all
 
 on:
   push:
-    branches: [ master ]
   pull_request:
-    branches: [ master ]
-
 
 jobs:
   build-and-test:

THIRD_PARTY_LICENSES.md

@@ -15,3 +15,19 @@
 **3** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-common` **Version:** `1.9.0`
 > - **POM Project URL**: [https://kotlinlang.org/](https://kotlinlang.org/)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+**4** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-jdk7` **Version:** `1.9.0`
+> - **POM Project URL**: [https://kotlinlang.org/](https://kotlinlang.org/)
+> - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+**5** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-jdk8` **Version:** `1.9.0`
+> - **POM Project URL**: [https://kotlinlang.org/](https://kotlinlang.org/)
+> - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+**6** **Group:** `org.jetbrains.kotlinx` **Name:** `kotlinx-collections-immutable-jvm` **Version:** `0.3.6`
+> - **POM Project URL**: [https://github.com/Kotlin/kotlinx.collections.immutable](https://github.com/Kotlin/kotlinx.collections.immutable)
+> - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Unknown
+
+**7** **Group:** `org.jetbrains.kotlinx` **Name:** `kotlinx-collections-immutable` **Version:** `0.3.6`

build.gradle.kts

@@ -1,13 +1,14 @@
+import com.diffplug.gradle.spotless.SpotlessTask
 import com.github.jk1.license.filter.LicenseBundleNormalizer
 import com.github.jk1.license.render.InventoryMarkdownReportRenderer
 import com.github.jk1.license.render.TextReportRenderer
+import java.time.Instant
+import java.util.Properties
 import org.gradle.kotlin.dsl.support.unzipTo
 import org.gradle.kotlin.dsl.support.zipTo
 import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
 import proguard.gradle.ProGuardTask
-import java.time.Instant
-import java.util.Properties
 
 buildscript {
     repositories {
@@ -72,13 +73,19 @@ java {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib:1.9.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-collections-immutable:0.3.6")
 
     testImplementation("org.junit.jupiter:junit-jupiter:5.7.1")
     testCompileOnly("junit:junit:4.13")
     testRuntimeOnly("org.junit.vintage:junit-vintage-engine")
     testImplementation("org.hamcrest:hamcrest:2.2")
     testImplementation("pl.pragmatists:JUnitParams:1.1.1")
     testImplementation("com.google.code.tempus-fugit:tempus-fugit:1.1")
+
+    // Used for the conformance test runner, because IonValue is not suitable for it.
+    testImplementation("com.amazon.ion:ion-element:1.2.0")
+    // Force the tests to use the locally built version rather than a version transitively provided by `ion-element`.
+    testImplementation(project)
 }
 
 group = "com.amazon.ion"
@@ -90,9 +97,9 @@ description = "A Java implementation of the Amazon Ion data notation."
 val isCI: Boolean = System.getenv("CI") == "true"
 val githubRepositoryUrl = "https://github.com/amazon-ion/ion-java/"
 val isReleaseVersion: Boolean = !version.toString().endsWith("SNAPSHOT")
-// The name we're checking for corresponds to the name that is set in the `publish-release-artifacts.yml` file.
-val isReleaseWorkflow: Boolean = System.getenv("GITHUB_WORKFLOW") == "Publish Release Artifacts"
-val generatedResourcesDir = "${layout.buildDirectory}/generated/main/resources"
+// Workflows triggered by a new release always have a tag ref.
+val isReleaseWorkflow: Boolean = (System.getenv("GITHUB_REF") ?: "").startsWith("refs/tags/")
+val generatedResourcesDir = layout.buildDirectory.dir("generated/main/resources")
 
 sourceSets {
     main {
@@ -105,7 +112,7 @@ licenseReport {
     // though ion-java does not depend on ion-java-cli. By default, the license report generator includes
     // the current project (ion-java) and all its subprojects.
     projects = arrayOf(project)
-    outputDir = "${layout.buildDirectory}/reports/licenses"
+    outputDir = layout.buildDirectory.dir("reports/licenses").get().asFile.path
     renderers = arrayOf(InventoryMarkdownReportRenderer(), TextReportRenderer())
     // Dependencies use inconsistent titles for Apache-2.0, so we need to specify mappings
     filters = arrayOf(
@@ -118,49 +125,67 @@ licenseReport {
     )
 }
 
+// Spotless eagerly checks for the `rachetFrom` git ref even if there are no spotless tasks in the task
+// graph, so we're going to use a git tag to create our own lazy evaluation and setting of `rachetFrom`.
+// See https://github.com/diffplug/spotless/issues/1902
+val SPOTLESS_TAG = "spotless-check-${Instant.now().epochSecond}-DELETE-ME"
+
 /**
- * This is the `git remote` name that corresponds to amazon-ion/ion-java.
- * It is used for applying the "spotless" checks only to things that are changed
- * compared to the master branch of the source repo.
+ * This is the commit where the current branch most recently forked from master. We use this as
+ * our "rachetFrom" base so that changes in master don't cause unexpected formatting failures in
+ * feature branches.
  */
-val sourceRepoRemoteName: String by lazy {
+val sourceRepoRachetFromCommit: String by lazy {
     val git = System.getenv("GIT_CLI") ?: "git"
 
     fun String.isSourceRepo(): Boolean {
-        val url = "$git remote get-url ${this@isSourceRepo}".runCommand()
+        val url = "$git remote get-url ${this@isSourceRepo}".trim().runCommand()
         return "amazon-ion/ion-java" in url || "amzn/ion-java" in url
     }
 
-    var name = "$git remote".runCommand().lines().firstOrNull { it.isSourceRepo() }
+    var remoteName = "$git remote".runCommand().trim().lines().firstOrNull { it.isSourceRepo() }
 
     if (isCI) {
         // When running on a CI environment e.g. GitHub Actions, we might need to automatically add the remote
-        if (name == null) {
-            name = "ci_source_repository"
-            "$git remote add $name $githubRepositoryUrl".runCommand()
+        if (remoteName == null) {
+            remoteName = "ci_source_repository"
+            "$git remote add $remoteName $githubRepositoryUrl".runCommand(log = logger::quiet)
+            logger.quiet("Added remote repository ")
         }
         // ...and make sure that we have indeed fetched that remote
-        "$git fetch $name".runCommand()
+        "$git fetch --unshallow --no-tags --no-recurse-submodules $remoteName master".runCommand()
     }
 
-    name ?: throw Exception(
+    remoteName ?: throw Exception(
         """
             |No git remote found for amazon-ion/ion-java. Try again after running:
             |
             |    git remote add -f <name> $githubRepositoryUrl
-            """.trimMargin()
+        """.trimMargin()
     )
+
+    // TODO: We might need to use the PR base ref when this is running as part of a CI check for a PR.
+    logger.quiet("Finding spotless ratchetFrom base...")
+    "$git merge-base $remoteName/master HEAD".runCommand(log = logger::quiet).trim()
 }
 
-fun String.runCommand(workingDir: File = rootProject.projectDir): String {
+fun String.runCommand(workingDir: File = rootProject.projectDir, log: (String) -> Unit = logger::info): String {
+    log("$ $this")
     val parts = this.split("\\s".toRegex())
     val proc = ProcessBuilder(*parts.toTypedArray())
         .directory(workingDir)
         .redirectOutput(ProcessBuilder.Redirect.PIPE)
         .redirectError(ProcessBuilder.Redirect.PIPE)
         .start()
     proc.waitFor(30, TimeUnit.SECONDS)
-    return proc.inputStream.bufferedReader().readText()
+    val stdOut = proc.inputStream.bufferedReader().readText()
+    val stdErr = proc.errorStream.bufferedReader().readText()
+    if (stdOut.isNotBlank()) log(stdOut)
+    if (stdErr.isNotBlank()) logger.warn(stdErr)
+    if (proc.exitValue() != 0) {
+        throw Exception("Failed to run command: $this")
+    }
+    return stdOut
 }
 
 spotless {
@@ -171,14 +196,19 @@ spotless {
     // release branch.
     if (isReleaseWorkflow) return@spotless
 
-    ratchetFrom("$sourceRepoRemoteName/master")
+    "git tag -f $SPOTLESS_TAG".runCommand()
+    ratchetFrom(SPOTLESS_TAG)
+    // Make sure this always gets cleaned up. We can't do it inline here, so we'll do it once the task graph is created.
+    gradle.taskGraph.addTaskExecutionGraphListener { "git tag -d $SPOTLESS_TAG".runCommand() }
 
     val shortFormLicenseHeader = """
         // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
         // SPDX-License-Identifier: Apache-2.0
     """.trimIndent()
 
     java {
+        // Note that the order of these is important. Each of these is an individual formatter
+        // that is applied sequentially.
         licenseHeader(shortFormLicenseHeader)
         removeUnusedImports()
     }
@@ -368,7 +398,7 @@ tasks {
     }
 
     ktlint {
-        version.set("0.40.0")
+        version.set("0.45.2")
         outputToConsole.set(true)
     }
 
@@ -384,7 +414,9 @@ tasks {
             }
         )
 
-        val spotbugsBaselineFile = "$rootDir/config/spotbugs/baseline.xml"
+        val spotbugsConfigDir = "$rootDir/config/spotbugs"
+        excludeFilter.set(file("$spotbugsConfigDir/exclude.xml"))
+        val spotbugsBaselineFile = "$spotbugsConfigDir/baseline.xml"
 
         val baselining = project.hasProperty("baseline") // e.g. `./gradlew :spotbugsMain -Pbaseline`
 
@@ -416,7 +448,7 @@ tasks {
                         commandLine(
                             "xsltproc",
                             "--output", spotbugsBaselineFile,
-                            "$rootDir/config/spotbugs/baseline.xslt",
+                            "$spotbugsConfigDir/baseline.xslt",
                             "${outputLocation.get()}"
                         )
                     }
@@ -441,7 +473,7 @@ tasks {
      * for why this is done with a properties file rather than the Jar manifest.
      */
     val generateJarInfo by creating<Task> {
-        val propertiesFile = File("$generatedResourcesDir/${project.name}.properties")
+        val propertiesFile = generatedResourcesDir.get().file("${project.name}.properties").asFile
         doLast {
             propertiesFile.parentFile.mkdirs()
             val properties = Properties()
@@ -528,6 +560,11 @@ tasks {
         dependsOn(jar)
         includeConfigs.set(listOf("runtimeClasspath"))
     }
+
+    withType<SpotlessTask> {
+        doFirst { "git tag -f $SPOTLESS_TAG $sourceRepoRachetFromCommit".runCommand() }
+        doLast { "git tag -d $SPOTLESS_TAG".runCommand() }
+    }
 }
 
 publishing {

config/spotbugs/exclude.xml

@@ -0,0 +1,28 @@
+
+
+<!-- This file specifies a spotbugs filter for excluding reports that
+     should not be considered errors.
+
+     The format of this file is documented at:
+
+       https://spotbugs.readthedocs.io/en/latest/filter.html
+
+     When possible, please specify the full names of the bug codes,
+     using the pattern attribute, to make it clearer what reports are
+     being suppressed.  You can find a listing of codes at:
+
+       https://spotbugs.readthedocs.io/en/latest/bugDescriptions.html
+  -->
+
+<FindBugsFilter>
+    <Match>
+        <Match>
+            <!--
+                Ignore Kotlin files, because SpotBugs doesn't provide specific Kotlin support,
+                so it raises warnings for things that might look dodgy in the byte code, but
+                were compiled from perfectly safe Kotlin code.
+            -->
+            <Source name="~.*\.kt"/>
+        </Match>
+    </Match>
+</FindBugsFilter>

ion-java-cli/build.gradle.kts

@@ -1,6 +1,8 @@
 plugins {
     java
     application
+    // Apply GraalVM Native Image plugin
+    id("org.graalvm.buildtools.native") version "0.10.3"
 }
 
 description = "A CLI that implements the standard interface defined by ion-test-driver."
@@ -15,8 +17,33 @@ repositories {
 dependencies {
     implementation("args4j:args4j:2.33")
     implementation(rootProject)
+
+    implementation("info.picocli:picocli:4.7.6")
+    annotationProcessor("info.picocli:picocli-codegen:4.7.6")
+}
+
+tasks.withType<JavaCompile> {
+    options.compilerArgs.add("-Aproject=${project.group}/${project.name}")
 }
 
 application {
     mainClass.set("com.amazon.tools.cli.IonJavaCli")
 }
+
+// Defines an ion-java-cli:nativeCompile task which produces ion-java-cli/build/native/nativeCompile/jion
+// You need to have GRAALVM_HOME pointed at a GraalVM installation
+// You can get one of those via e.g. `sdk install java 17.0.9-graalce`
+// See: https://sdkman.io/
+graalvmNative {
+    testSupport.set(false)
+    binaries {
+        named("main") {
+            imageName.set("jion")
+            mainClass.set("com.amazon.tools.cli.SimpleIonCli")
+            buildArgs.add("-O4")
+        }
+    }
+    binaries.all {
+        buildArgs.add("--verbose")
+    }
+}