enhancement/bento-35: Use Gradle convention script plugins.

CONTRIBUTING.md

@@ -14,4 +14,4 @@ I know some features are large in scope, just break down what you can where poss
 
 ## License
 
-BentoFX is licensed under the MIT License. Anything you contribute will thus also be under the MIT license.
+BentoFX is licensed under the MIT License. Anything you contribute will thus also be under the MIT license.

README.md

@@ -6,8 +6,8 @@ A docking system for JavaFX.
 
 Requirements:
 
-- JavaFX 19+
-- Java 17+
+- JavaFX 21+
+- Java 21+
 
 Gradle syntax:
 

build-logic/build.gradle

@@ -0,0 +1,16 @@
+plugins {
+    id 'groovy-gradle-plugin'
+}
+
+description =
+        'Used to apply plugins to projects and to configure dependencies and tasks. Runs during project ' +
+                'configuration, after settings.'
+
+dependencies {
+    implementation gradleApi()
+    implementation localGroovy()
+
+    implementation libs.benmanes.versions.gradlePlugin.dependency
+    implementation libs.javafx.gradlePlugin.dependency
+    implementation libs.jreleaser.gradlePlugin.dependency
+}

build-logic/gradle.properties

@@ -0,0 +1,2 @@
+org.gradle.caching=true
+org.gradle.jvmargs=-Xmx2500m -Dfile.encoding=UTF-8

build-logic/settings.gradle

@@ -0,0 +1,20 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+    versionCatalogs {
+        libs {
+            from(files('../gradle/libs.versions.toml'))
+        }
+    }
+}
+
+rootProject.name = 'build-logic'

build-logic/src/main/groovy/bento.project.build-lifecycle.gradle

@@ -0,0 +1,6 @@
+import static software.coley.gradle.lifecycle.BuildLifecycle.ALL_CLASSES_TASK_NAME
+
+tasks.register(ALL_CLASSES_TASK_NAME) {
+    description = 'Compiles all main and test code for all applicable subprojects and test suites.'
+    group = LifecycleBasePlugin.BUILD_GROUP
+}

build-logic/src/main/groovy/bento.project.project-convention.gradle

@@ -0,0 +1,120 @@
+import org.gradle.api.plugins.jvm.JvmTestSuite
+import org.gradlex.jvm.dependency.conflict.detection.rules.CapabilityDefinition.*
+import software.coley.gradle.artifacts.TestFxAlignmentRule
+import software.coley.gradle.task.extensions.BentoConventionExtension
+
+import static software.coley.gradle.lifecycle.BuildLifecycle.ALL_CLASSES_TASK_NAME
+
+plugins {
+    id 'java-library'
+    id 'com.github.ben-manes.versions'
+    id 'bento.project.build-lifecycle'
+    id 'bento.test.unit-test-suite'
+}
+
+def versionCatalog = versionCatalogs.named('libs')
+
+group = 'software.coley.bento-fx'
+version = versionCatalog.findVersion("bentofx").get().requiredVersion
+
+def normalizedProjectName = providers.provider {
+    project.path.substring(1).replace(':', '.')
+}
+
+extensions.create('bentoConvention', BentoConventionExtension, normalizedProjectName)
+
+// Get the Java JDK version specified in libs.versions.toml and accommodate all
+// the different ways Gradle and its plugins take the Java version...
+def jdkVersion = versionCatalog.findVersion("java-jdk").get().requiredVersion
+def javaLanguageVersion = JavaLanguageVersion.of(jdkVersion)
+def javaMajorVersionAsInt = javaLanguageVersion.asInt()
+
+dependencies {
+
+    components.all(TestFxAlignmentRule)
+
+    api platform(project(':platform'))
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(javaMajorVersionAsInt)
+    }
+
+    withSourcesJar()
+    withJavadocJar()
+}
+
+javadoc {
+    options {
+        addStringOption('Xdoclint:none', '-quiet')
+    }
+}
+
+testing {
+    suites {
+        configureEach { suite ->
+            if (suite instanceof JvmTestSuite) {
+
+                def junitVersion =
+                        versionCatalog.findVersion('junit').get().requiredVersion
+
+                useJUnitJupiter(junitVersion)
+
+                targets.configureEach {
+                    testTask.configure {
+                        it.filter {
+                            includeTestsMatching '*Test'
+                            includeTestsMatching '*Test\$*'
+                            failOnNoDiscoveredTests = false
+                        }
+
+                        // Set system properties for the test JVM(s)
+                        systemProperty 'project.name', rootProject.name
+                        // Turns out we really DO need a graphics environment
+                        // to initialize the JavaFx platform used by some
+                        // JUnit tests. Therefore, we can NOT run JUnit
+                        // tests headless.
+                        systemProperty 'java.awt.headless', 'false'
+                    }
+                }
+            }
+        }
+    }
+}
+
+tasks.named(ALL_CLASSES_TASK_NAME) {
+    dependsOn(tasks.named('classes'))
+}
+
+tasks.withType(JavaCompile).configureEach {
+    it.options.with {
+        encoding = 'UTF-8'
+        release = javaMajorVersionAsInt
+        fork = true
+        forkOptions.memoryMaximumSize = '1g'
+        options.compilerArgs << '-parameters'
+    }
+}
+
+tasks.withType(Jar).configureEach {
+    archiveBaseName = normalizedProjectName
+
+    from(project.isolated.rootProject.projectDirectory) {
+        include 'LICENSE'
+        into 'META-INF'
+        rename { 'LICENSE.txt' }
+    }
+}
+
+tasks.withType(JavaExec).configureEach {
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = javaLanguageVersion
+    }
+}
+
+tasks.withType(Test).configureEach {
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = javaLanguageVersion
+    }
+}

build-logic/src/main/groovy/bento.release.publish-convention.gradle

@@ -0,0 +1,51 @@
+plugins {
+    id 'java'
+    id 'bento.project.project-convention'
+    id 'maven-publish'
+}
+
+def bentoConvention = extensions.getByName('bentoConvention')
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            artifactId = bentoConvention.normalizedProjectName.get()
+
+            from components['java']
+
+            pom {
+                url.set( 'https://github.com/Col-E/BentoFX')
+                inceptionYear.set( '2025')
+
+                licenses {
+                    license {
+                        name.set( 'MIT')
+                        url.set( 'https://spdx.org/licenses/MIT.html')
+                    }
+                }
+                developers {
+                    developer {
+                        id =  'Col-E'
+                        name =  'Matt Coley'
+                    }
+                    developer {
+                        id.set( 'philliplbryant')
+                        name.set( 'Phil Bryant')
+                    }
+                }
+                scm {
+                    connection.set( 'scm:git:https://github.com/Col-E/BentoFX.git')
+                    developerConnection.set( 'scm:git:ssh://github.com/Col-E/BentoFX.git')
+                    url.set( 'https://github.com/Col-E/BentoFX')
+                }
+            }
+        }
+    }
+
+    repositories {
+        mavenLocal()
+        maven {
+            url = uri(layout.buildDirectory.dir( 'staging-deploy'))
+        }
+    }
+}

build-logic/src/main/groovy/bento.test.unit-test-suite.gradle

@@ -0,0 +1,14 @@
+import static software.coley.gradle.lifecycle.BuildLifecycle.ALL_CLASSES_TASK_NAME
+
+plugins {
+    id 'bento.project.build-lifecycle'
+    id 'jvm-test-suite'
+}
+
+tasks.named(ALL_CLASSES_TASK_NAME) {
+    dependsOn tasks.named('testClasses')
+}
+
+tasks.named('check') {
+    dependsOn(tasks.named('test'))
+}

build-logic/src/main/groovy/software/coley/gradle/artifacts/TestFxAlignmentRule.groovy

@@ -0,0 +1,14 @@
+package software.coley.gradle.artifacts
+
+import org.gradle.api.artifacts.ComponentMetadataContext
+import org.gradle.api.artifacts.ComponentMetadataRule
+
+abstract class TestFxAlignmentRule implements ComponentMetadataRule {
+    @Override
+    void execute(ComponentMetadataContext ctx) {
+        def id = ctx.details.id
+        if (id.group == 'org.testfx' && id.name != 'openjfx-monocle') {
+            ctx.details.belongsTo("org.testfx:testfx-virtual-bom:${id.version}")
+        }
+    }
+}

build-logic/src/main/groovy/software/coley/gradle/lifecycle/BuildLifecycle.groovy

@@ -0,0 +1,11 @@
+package software.coley.gradle.lifecycle
+
+final class BuildLifecycle {
+    public static final String ALL_CLASSES_TASK_NAME = 'allClasses'
+
+    private BuildLifecycle() {
+        throw new UnsupportedOperationException(
+                'Utility classes should not be instantiated.'
+        )
+    }
+}

build-logic/src/main/groovy/software/coley/gradle/task/extensions/BentoConventionExtension.groovy

@@ -0,0 +1,26 @@
+package software.coley.gradle.task.extensions
+
+import org.gradle.api.provider.Provider
+
+import javax.inject.Inject
+
+/**
+ * Extension class for sharing lazily calculated values among precompiled
+ * convention script plugins.
+ */
+abstract class BentoConventionExtension {
+    /**
+     * The fully qualified project name, normalized as a valid for use as an
+     * artifact ID, JAR file name, etc.
+     */
+    final Provider<String> normalizedProjectName
+
+    /**
+     * @param normalizedProjectName The fully qualified project name,
+     * normalized as a valid for use as an artifact ID, JAR file name, etc.
+     */
+    @Inject
+    BentoConventionExtension(final Provider<String> normalizedProjectName) {
+        this.normalizedProjectName = normalizedProjectName
+    }
+}