Refactor template using buildSrc, feature variants and published version catalogs (#56)

Co-authored-by: Abe Pazos <abe@hamoid.com>

buildSrc/src/main/kotlin/conventions/distribute-application.gradle.kts

@@ -0,0 +1,73 @@
+package conventions
+import org.gradle.internal.os.OperatingSystem
+import kotlin.collections.set
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+plugins {
+    id("com.gradleup.shadow")
+    id("org.beryx.runtime")
+}
+
+val applicationMainClass: String by properties
+
+application {
+    mainClass = if (hasProperty("openrndr.application"))
+        "${property("openrndr.application")}"
+    else
+        applicationMainClass
+}
+
+tasks {
+    named<ShadowJar>("shadowJar") {
+        manifest {
+            attributes["Main-Class"] = applicationMainClass
+            attributes["Implementation-Version"] = project.version
+        }
+        minimize {
+            exclude(dependency("org.openrndr:openrndr-gl3:.*"))
+            exclude(dependency("org.jetbrains.kotlin:kotlin-reflect:.*"))
+            exclude(dependency("org.slf4j:slf4j-simple:.*"))
+            exclude(dependency("org.apache.logging.log4j:log4j-slf4j2-impl:.*"))
+            exclude(dependency("com.fasterxml.jackson.core:jackson-databind:.*"))
+            exclude(dependency("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:.*"))
+            exclude(dependency("org.bytedeco:.*"))
+        }
+    }
+}
+
+tasks {
+    named<org.beryx.runtime.JPackageTask>("jpackage") {
+        doLast {
+            val destPath = if (OperatingSystem.current().isMacOsX)
+                "build/jpackage/openrndr-application.app/Contents/Resources/data"
+            else
+                "build/jpackage/openrndr-application/data"
+
+            copy {
+                from("data") { include("**/*") }
+                into(destPath)
+            }
+        }
+    }
+
+    register<Zip>("jpackageZip") {
+        archiveFileName = "openrndr-application.zip"
+        from("${layout.buildDirectory.get()}/jpackage") {
+            include("**/*")
+        }
+        dependsOn("jpackage")
+    }
+}
+
+runtime {
+    jpackage {
+        imageName = "openrndr-application"
+        skipInstaller = true
+        if (OperatingSystem.current().isMacOsX) {
+            jvmArgs.add("-XstartOnFirstThread")
+            jvmArgs.add("-Duser.dir=${"$"}APPDIR/../Resources")
+        }
+    }
+    options = listOf("--strip-debug", "--compress", "1", "--no-header-files", "--no-man-pages")
+    modules = listOf("jdk.unsupported", "java.management", "java.desktop")
+}

buildSrc/src/main/kotlin/conventions/kotlin-jvm.gradle.kts

@@ -0,0 +1,71 @@
+package conventions
+import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+
+val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+plugins {
+    java
+    kotlin("jvm")
+    id("com.github.ben-manes.versions")
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    targetCompatibility = JavaVersion.valueOf("VERSION_${libs.findVersion("jvmTarget").get().displayName}")
+    sourceCompatibility = JavaVersion.valueOf("VERSION_${libs.findVersion("jvmTarget").get().displayName}")
+}
+
+kotlin {
+    compilerOptions {
+        apiVersion.set(KotlinVersion.valueOf("KOTLIN_${libs.findVersion("kotlinApi").get().displayName.replace(".", "_")}"))
+        languageVersion.set(KotlinVersion.valueOf("KOTLIN_${libs.findVersion("kotlinLanguage").get().displayName.replace(".", "_")}"))
+        jvmTarget.set(JvmTarget.valueOf("JVM_${libs.findVersion("jvmTarget").get().displayName}"))
+    }
+}
+
+fun arch(arch: String = System.getProperty("os.arch")): String {
+    return when (arch) {
+        "x86-64", "x86_64", "amd64" -> "x86-64"
+        "arm64", "aarch64" -> "aarch64"
+        else -> error("unsupported arch $arch")
+    }
+}
+
+fun Project.addHostMachineAttributesToRuntimeConfigurations() {
+    val currentOperatingSystemName: String = DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName()
+    val currentArchitectureName: String = arch()
+
+    configurations.matching {
+        it.name.endsWith("runtimeClasspath", ignoreCase = true)
+    }.configureEach {
+        attributes {
+            attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objects.named(currentOperatingSystemName))
+            attribute(MachineArchitecture.ARCHITECTURE_ATTRIBUTE, objects.named(currentArchitectureName))
+        }
+    }
+}
+
+addHostMachineAttributesToRuntimeConfigurations()
+
+
+tasks {
+    dependencyUpdates {
+        gradleReleaseChannel = "current"
+
+        val nonStableKeywords = listOf("alpha", "beta", "rc")
+
+        fun isNonStable(version: String) = nonStableKeywords.any {
+            version.lowercase().contains(it)
+        }
+
+        rejectVersionIf {
+            isNonStable(candidate.version) && !isNonStable(currentVersion)
+        }
+    }
+}

buildSrc/src/main/kotlin/conventions/openrndr-tasks.gradle.kts

@@ -0,0 +1,42 @@
+package conventions
+
+val applicationMainClass by properties
+tasks.register("create executable jar for $applicationMainClass") {
+    group = " \uD83E\uDD8C OPENRNDR"
+    dependsOn("shadowJar")
+}
+
+tasks.register("run $applicationMainClass") {
+    group = " \uD83E\uDD8C OPENRNDR"
+    dependsOn("run")
+}
+
+tasks.register("create standalone executable for $applicationMainClass") {
+    group = " \uD83E\uDD8C OPENRNDR"
+    dependsOn("jpackageZip")
+}
+
+tasks.register("add IDE file scopes") {
+    group = " \uD83E\uDD8C OPENRNDR"
+    val scopesFolder = File("${project.projectDir}/.idea/scopes")
+    scopesFolder.mkdirs()
+
+    val files = listOf(
+        "Code" to "file:*.kt||file:*.frag||file:*.vert||file:*.glsl",
+        "Text" to "file:*.txt||file:*.md||file:*.xml||file:*.json",
+        "Gradle" to "file[*buildSrc*]:*/||file:*gradle.*||file:*.gradle||file:*/gradle-wrapper.properties||file:*.toml",
+        "Media" to "file:*.png||file:*.jpg||file:*.dds||file:*.exr||file:*.mp3||file:*.wav||file:*.mp4||file:*.mov||file:*.svg"
+    )
+    files.forEach { (name, pattern) ->
+        val file = File(scopesFolder, "__$name.xml")
+        if (!file.exists()) {
+            file.writeText(
+                """
+                    <component name="DependencyValidationManager">
+                      <scope name=" ★ $name" pattern="$pattern" />
+                    </component>
+                    """.trimIndent()
+            )
+        }
+    }
+}

buildSrc/src/main/kotlin/conventions/publish-library.gradle.kts

@@ -0,0 +1,37 @@
+package conventions
+
+import org.gradle.kotlin.dsl.java
+import org.gradle.kotlin.dsl.kotlin
+
+plugins {
+    java
+    kotlin("jvm")
+    `maven-publish`
+}
+
+val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+val openrndr = extensions.getByType<VersionCatalogsExtension>().named("openrndr")
+
+val demo = sourceSets.create("demo")
+val main = sourceSets.getByName("main")
+
+demo.compileClasspath += main.compileClasspath
+demo.runtimeClasspath += main.runtimeClasspath
+demo.compileClasspath += main.output
+demo.runtimeClasspath += main.output
+
+dependencies {
+    "demoRuntimeOnly"(openrndr.findLibrary("gl3").get())
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            from(components["java"])
+            groupId = property("project.group")?.toString() ?: error("project.group not set")
+            artifactId = property("project.name")?.toString() ?: error("project.name not set")
+            description = property("project.name")?.toString() ?: error("project.name not set")
+            version = property("project.version")?.toString() ?: error("project.version not set")
+        }
+    }
+}