publish fully versioned artifacts to maven.daporkchop.net

This eliminates the need to use JitPack or similar services to get maven artifacts pinned to a specific CubicChunks version.

Author: DaMatrix

Jenkinsfile

@@ -54,6 +54,11 @@ pipeline {
                 }
             }
         }
+        stage("Publish") {
+            steps {
+                sh "./gradlew publish -x test"
+            }
+        }
     }
 
     post {

build.gradle.kts

@@ -320,6 +320,8 @@ artifacts {
 publishing {
     repositories {
         maven {
+            name = "Sonatype"
+
             val user = (project.properties["sonatypeUsername"] ?: System.getenv("sonatypeUsername")) as String?
             val pass = (project.properties["sonatypePassword"] ?: System.getenv("sonatypePassword")) as String?
             val local = user == null || pass == null
@@ -338,21 +340,40 @@ publishing {
                 }
             }
         }
+
+        //only register maven.daporkchop.net repository if these environment variables are set
+        val daporkchopMavenUsername = (project.properties["daporkchopMavenUsername"] ?: System.getenv("daporkchopMavenUsername")) as String?
+        val daporkchopMavenPassword = (project.properties["daporkchopMavenPassword"] ?: System.getenv("daporkchopMavenPassword")) as String?
+        if (daporkchopMavenUsername != null && daporkchopMavenPassword != null) {
+            maven {
+                name = "DaPorkchop_"
+
+                val releasesRepoUrl = "https://maven.daporkchop.net/release/"
+                val snapshotsRepoUrl = "https://maven.daporkchop.net/snapshot/"
+
+                setUrl(if (doRelease.toBoolean()) releasesRepoUrl else snapshotsRepoUrl)
+                credentials {
+                    username = daporkchopMavenUsername
+                    password = daporkchopMavenPassword
+                }
+            }
+        }
     }
     publications {
-        create("mod", MavenPublication::class) {
-            version = project.ext["mavenProjectVersion"]!!.toString()
-            artifactId = base.archivesBaseName.toLowerCase()
-            artifact(tasks["sourcesJar"]) {
+        fun configureArtifacts(publication: MavenPublication) {
+            publication.artifact(tasks["sourcesJar"]) {
                 classifier = "sources"
             }
-            artifact(tasks["shadowJar"]) {
+            publication.artifact(tasks["shadowJar"]) {
                 classifier = ""
             }
-            artifact(tasks["devShadowJar"]) {
+            publication.artifact(tasks["devShadowJar"]) {
                 classifier = "dev"
             }
-            pom {
+        }
+
+        fun configurePom(publication: MavenPublication) {
+            publication.pom {
                 name.set(projectName)
                 description.set("CubicChunks customizable world generator")
                 packaging = "jar"
@@ -385,8 +406,41 @@ publishing {
                 }
             }
         }
+
+        create<MavenPublication>("mod") {
+            version = project.ext["mavenProjectVersion"]!!.toString()
+            artifactId = base.archivesBaseName.toLowerCase()
+
+            configureArtifacts(this)
+            configurePom(this)
+        }
+
+        //same as "mod", but using the full project version from mcGitVersion instead of mavenProjectVersion.
+        create<MavenPublication>("versionedMod") {
+            version = project.version.toString()
+            artifactId = base.archivesBaseName.toLowerCase()
+
+            configureArtifacts(this)
+            configurePom(this)
+        }
+    }
+
+    //all publish tasks should depend on all of the tasks which generate the artifacts being published
+    tasks.withType<AbstractPublishToMaven>().configureEach {
+        dependsOn("sourcesJar", "shadowJar", "devShadowJar")
+    }
+
+    //this is kinda gross, but is apparently the recommended way to conditionally publish specific publications to specific repositories:
+    //  see https://docs.gradle.org/current/userguide/publishing_customization.html#sec:publishing_maven:conditional_publishing
+    tasks.withType<PublishToMavenRepository>().configureEach {
+        val predicate = provider {
+            (publication == publications["mod"] && repository == repositories["Sonatype"]) ||
+            (publication == publications["versionedMod"] && repository == repositories["DaPorkchop_"])
+        }
+        onlyIf("publishing mod to Sonatype repository, and versioned mod to DaPorkchop_ repository") {
+            predicate.get()
+        }
     }
-    tasks["publishModPublicationToMavenRepository"].dependsOn("sourcesJar", "shadowJar", "devShadowJar")
 }
 
 signing {

jitpack.yml

@@ -1,4 +1,5 @@
 jdk:
   - openjdk8
 install:
-   - ./gradlew build publishToMavenLocal
+   - ./gradlew setupCiWorkspace
+   - ./gradlew build publishVersionedModPublicationToMavenLocal