Update project setup

Author: malczuuu

PUBLISHING.md

@@ -0,0 +1,28 @@
+# Publishing
+
+Keep Git tags with `vX.Y.Z-suffix` format. GitHub Actions job will only trigger on such tags and will remove `v` prefix.
+
+See [`gradle-release.yml`](.github/workflows/gradle-release.yml) for whole publishing procedure.
+
+Set the following environment variables in your CI/CD (GitHub Actions, etc.):
+
+```txt
+# generated tokens on Sonatype account, do not use real username/password
+PUBLISHING_USERNAME=<username>
+PUBLISHING_PASSWORD=<password>
+
+# generated PGP key for signing artifacts
+SIGNING_KEY=<PGP key>
+SIGNING_PASSWORD=<PGP password>
+```
+
+Artifacts are published to Maven Central via Sonatype, using following Gradle task.
+
+```bash
+./gradlew -Pversion=<version> -Psign publishAggregationToCentralPortal
+```
+
+This command uses `nmcp` Gradle plugin - [link](https://github.com/GradleUp/nmcp).
+
+**Note** that this only uploads the artifacts to Sonatype repository. You need to manually log in to Sonatype to push
+the artifacts to Maven Central.

build.gradle

@@ -0,0 +1,139 @@
+import com.diffplug.spotless.LineEnding
+
+plugins {
+    id("java-library")
+    id("maven-publish")
+    id("signing")
+    id("com.diffplug.spotless").version("7.2.1")
+    id("com.gradleup.nmcp.aggregation").version("1.1.0")
+}
+
+group = "io.github.malczuuu.problem4j"
+
+/**
+ * In order to avoid hardcoding snapshot versions, we derive the version from the current Git commit hash. For CI/CD add
+ * -Pversion={releaseVersion} parameter to match Git tag.
+ */
+version =
+    if (version == "unspecified")
+        getSnapshotVersion(rootProject.rootDir)
+    else
+        version
+
+java {
+    toolchain.languageVersion = JavaLanguageVersion.of(8)
+    withSourcesJar()
+    withJavadocJar()
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation(platform("org.junit:junit-bom:5.13.4"))
+
+    testImplementation("org.junit.jupiter:junit-jupiter")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            groupId = project.group.toString()
+            artifactId = project.name
+            version = project.version.toString()
+            from(components["java"])
+
+            pom {
+                name = project.name
+                description = "Core library implementing Problem model according to RFC7807"
+                url = "https://github.com/malczuuu/${project.name}"
+                inceptionYear = "2025"
+                licenses {
+                    license {
+                        name = "MIT License"
+                        url = "https://opensource.org/licenses/MIT"
+                    }
+                }
+                developers {
+                    developer {
+                        id = "malczuuu"
+                        name = "Damian Malczewski"
+                        url = "https://github.com/malczuuu"
+                    }
+                }
+                issueManagement {
+                    system = "GitHub Issues"
+                    url = "https://github.com/malczuuu/${project.name}/issues"
+                }
+                scm {
+                    connection = "scm:git:git://github.com/malczuuu/${project.name}.git"
+                    developerConnection = "scm:git:[email protected]:malczuuu/${project.name}.git"
+                    url = "https://github.com/malczuuu/${project.name}"
+                }
+            }
+        }
+    }
+}
+
+nmcpAggregation {
+    centralPortal {
+        username = System.getenv("PUBLISHING_USERNAME")
+        password = System.getenv("PUBLISHING_PASSWORD")
+
+        publishingType = "USER_MANAGED"
+    }
+    publishAllProjectsProbablyBreakingProjectIsolation()
+}
+
+signing {
+    if (project.hasProperty("sign")) {
+        useInMemoryPgpKeys(
+            System.getenv("SIGNING_KEY"),
+            System.getenv("SIGNING_PASSWORD")
+        )
+        sign(publishing.publications["maven"])
+    }
+}
+
+spotless {
+    format("misc") {
+        target("**/*.gradle.kts", "**/.gitattributes", "**/.gitignore")
+
+        trimTrailingWhitespace()
+        leadingTabsToSpaces(4)
+        endWithNewline()
+        lineEndings = LineEnding.UNIX
+    }
+
+    java {
+        target("src/**/*.java")
+
+        googleJavaFormat("1.28.0")
+        lineEndings = LineEnding.UNIX
+    }
+}
+
+tasks.register("printVersion") {
+    doLast {
+        println("Project version: $version")
+    }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    options.compilerArgs.add("-parameters")
+}
+
+/**
+ * Disable doclint to avoid errors and warnings on missing JavaDoc comments.
+ */
+tasks.withType<Javadoc>().configureEach {
+    (options as StandardJavadocDocletOptions).apply {
+        addStringOption("Xdoclint:none", "-quiet")
+    }
+}
+
+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+}

build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id "groovy"
+    `kotlin-dsl`
 }
 
 repositories {
@@ -8,5 +8,4 @@ repositories {
 
 dependencies {
     implementation("org.eclipse.jgit:org.eclipse.jgit:7.3.0.202506031305-r")
-    implementation(localGroovy())
 }

buildSrc/build.gradle renamed to buildSrc/build.gradle.kts

@@ -0,0 +1,33 @@
+import org.eclipse.jgit.revwalk.RevCommit
+import org.eclipse.jgit.revwalk.RevWalk
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder
+import java.io.File
+
+private const val UNSPECIFIED = "unspecified"
+
+/**
+ * Returns a snapshot version string based on the abbreviated Git commit hash of HEAD.
+ * On error, returns "unspecified".
+ *
+ * @param projectRootDir the root directory of the project (containing .git)
+ */
+fun getSnapshotVersion(projectRootDir: File): String {
+    return try {
+        val builder = FileRepositoryBuilder()
+            .setGitDir(File(projectRootDir, ".git"))
+            .readEnvironment()
+            .findGitDir()
+
+        builder.build().use { repository ->
+            val headId = repository.resolve("HEAD") ?: return UNSPECIFIED
+
+            RevWalk(repository).use { revWalk ->
+                val headCommit: RevCommit = revWalk.parseCommit(headId)
+                headCommit.id.name.substring(0, 7)
+            }
+        }
+    } catch (e: Exception) {
+        System.err.println("Error determining version: $e")
+        UNSPECIFIED
+    }
+}