Creder/allowing for multibranch custom workspaces

build.gradle.kts

@@ -1,16 +1,15 @@
-import org.jetbrains.dokka.gradle.DokkaTask
-import java.net.URL
 import com.code42.version.Version
+import com.diffplug.gradle.spotless.SpotlessExtension
+import org.jetbrains.dokka.gradle.DokkaTask
 
-val kotlinVersion = "1.9.22"
+val kotlinVersion = "1.9.23"
 
 plugins {
     base
-    kotlin("jvm") version "1.9.22"
+    kotlin("jvm") version "1.9.23"
     id("idea")
-    // maven plugin removed (invalid here)
     `maven-publish`
-    // Spotless plugin disabled
+    id("com.diffplug.spotless").version("6.25.0")
     id("org.jetbrains.dokka").version("1.9.0")
     id("io.gitlab.arturbosch.detekt").version("1.23.0")
     jacoco
@@ -21,116 +20,162 @@ val baseProjectName = "pipelinekt"
 val publishedProjects = listOf("core", "internal", "dsl")
 val activeProjects = publishedProjects
 
+val ktlintVersion = "1.1.1"
+val kotlinRules = mapOf(
+    "max_line_length" to "150",
+)
+
 allprojects {
     group = "com.code42"
     version = Version.getVersion()
 
     repositories {
         mavenCentral()
+        maven { url = uri("https://jitpack.io") }
     }
-}
 
-tasks.named<DokkaTask>("dokkaGfm") {
-    outputDirectory.set(file("${project.rootDir}/docs/dokka"))
-    dokkaSourceSets {
-        named("main") {
-            sourceLink {
-                localDirectory.set(file("./"))
-                remoteUrl.set(URL("https://github.com/$githubRepo/tree/master"))
-                remoteLineSuffix.set("#L")
-            }
+    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+        kotlinOptions {
+            jvmTarget = "17" // Using JDK 17 which is supported by detekt
         }
     }
+
+    tasks.withType<JavaCompile> {
+        sourceCompatibility = "17"
+        targetCompatibility = "17"
+    }
+}
+
+// Root-level spotless configuration
+spotless {
+    kotlin {
+        target("**/*.kt")
+        ktlint(ktlintVersion).editorConfigOverride(kotlinRules)
+        trimTrailingWhitespace()
+        endWithNewline()
+    }
+    kotlinGradle {
+        target("**/*.gradle.kts")
+        ktlint(ktlintVersion).editorConfigOverride(kotlinRules)
+        trimTrailingWhitespace()
+        endWithNewline()
+    }
 }
 
 tasks {
-    register("incrementVersion") {
+    create("incrementVersion") {
         doLast {
             Version.incrementVersion()
         }
     }
 }
 
-tasks.build {
-    finalizedBy("dokkaGfm")
+tasks.named("build") {
+    // Don't finalize with dokka as it's a top-level task that doesn't exist
+    // finalizedBy("dokka")
 }
 
 subprojects {
     apply(plugin = "org.jetbrains.kotlin.jvm")
 
+    if (!base.archivesName.get().startsWith("pipelinekt-")) {
+        base.archivesName.set("pipelinekt-${base.archivesName.get()}")
+    }
+
     dependencies {
         implementation(kotlin("stdlib-jdk8", kotlinVersion))
         implementation(kotlin("reflect", kotlinVersion))
         testImplementation("org.jetbrains.kotlin:kotlin-test")
         testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
     }
 
-    java {
-        toolchain {
-            languageVersion.set(JavaLanguageVersion.of(21))
+    // Skip the example module for spotless check
+    if (project.name == "examples") {
+        tasks.withType<com.diffplug.gradle.spotless.SpotlessTask> {
+            enabled = false
         }
     }
 
-    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
-        kotlinOptions {
-            jvmTarget = "21"
-        }
-    }
-
     tasks.withType<Test> {
         // Temporarily disable tests until we update them
         enabled = false
     }
-    
+
     tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
         if (this.name.contains("Test")) {
             enabled = false
         }
     }
 
     if (publishedProjects.contains(project.name)) {
-    apply(plugin = "org.gradle.maven-publish")
-    // Spotless fully disabled
+        apply(plugin = "org.gradle.maven-publish")
+        apply(plugin = "com.diffplug.spotless")
         apply(plugin = "io.gitlab.arturbosch.detekt")
         apply(plugin = "org.gradle.jacoco")
         apply(plugin = "org.jetbrains.dokka")
 
-        val sourcesJar by tasks.registering(Jar::class) {
+        configure<SpotlessExtension> {
+            kotlin {
+                target("src/**/*.kt")
+                ktlint(ktlintVersion).editorConfigOverride(kotlinRules)
+                trimTrailingWhitespace()
+                endWithNewline()
+            }
+            kotlinGradle {
+                target("*.gradle.kts")
+                ktlint(ktlintVersion).editorConfigOverride(kotlinRules)
+                trimTrailingWhitespace()
+                endWithNewline()
+            }
+        }
+
+        val sourcesJar by tasks.creating(Jar::class) {
             archiveClassifier.set("sources")
             from(sourceSets.main.get().allSource)
         }
 
         jacoco {
-            toolVersion = "0.8.10"
+            toolVersion = "0.8.7"
+        }
+
+        tasks.register("dokkaKdoc", org.jetbrains.dokka.gradle.DokkaTask::class) {
+            outputDirectory.set(file("$buildDir/kdoc"))
+            dokkaSourceSets {
+                named("main") {
+                    sourceLink {
+                        localDirectory.set(file("./"))
+                        remoteUrl.set(uri("https://github.com/$githubRepo/tree/master").toURL())
+                        remoteLineSuffix.set("#L")
+                    }
+                }
+            }
+        }
+
+        val kdocJar by tasks.creating(Jar::class) {
+            group = JavaBasePlugin.DOCUMENTATION_GROUP
+            dependsOn(tasks.named("dokkaKdoc"))
+            archiveClassifier.set("javadoc")
+            from("$buildDir/kdoc")
         }
 
         artifacts {
-            add("archives", sourcesJar.get())
+            add("archives", sourcesJar)
+            add("archives", kdocJar)
         }
 
         tasks.withType<JacocoReport> {
             reports {
                 xml.required.set(false)
                 csv.required.set(false)
                 html.required.set(true)
-                html.outputLocation.set(layout.buildDirectory.dir("reports/coverage").get().asFile)
+                html.outputLocation.set(file("$buildDir/reports/coverage"))
             }
         }
 
         tasks.build {
             finalizedBy("jacocoTestReport")
         }
 
-        // spotless {
-        //     kotlin {
-        //         ktlint()
-        //     }
-        //     kotlinGradle {
-        //         target("*.gradle.kts'", "additionalScripts/*.gradle.kts")
-        //         ktlint()
-        //     }
-        // }
-
         detekt {
             source.setFrom(files("src/main/kotlin", "src/test/kotlin"))
             baseline = file("detekt-${project.name}-baseline.xml")
@@ -140,46 +185,45 @@ subprojects {
 
         tasks.withType<io.gitlab.arturbosch.detekt.Detekt> {
             exclude(".*/resources/.*,.*/build/.*")
-            jvmTarget = "19"
+            jvmTarget = "17" // Use JDK 17 instead of 21 for detekt
             config.setFrom(files("${project.rootDir}/config/detekt/detekt.yml"))
-            // Skip detekt for now until we can fix the baselines
+            // Skip this task to make the build work for now
             enabled = false
         }
 
+        val tag = System.getProperty("tag")
+        val libVersion = if (tag.isNullOrEmpty()) project.version.toString() else tag + "-SNAPSHOT"
+        println("PUBLISHING- groupId: $group version: $libVersion artifactId: ${base.archivesName.get()}")
         publishing {
             publications {
                 create<MavenPublication>("maven") {
                     groupId = group.toString()
-                    version = project.version.toString()
-                    artifactId = "pipelinekt-${project.name}"
+                    version = libVersion
+                    artifactId = base.archivesName.get()
                     from(components["java"])
-                    artifact(sourcesJar.get())
+                    artifact(sourcesJar)
+                    artifact(kdocJar)
                 }
             }
             repositories {
                 mavenLocal()
                 maven {
-                    name = "GitHubPackages"
-                    url = uri("https://maven.pkg.github.com/$githubRepo")
-                    val token = System.getenv("GITHUB_TOKEN")
-                    if (token != null) {
-                        credentials(HttpHeaderCredentials::class) {
-                            name = "Authorization"
-                            value = "Bearer ${token}"
-                        }
-                        authentication {
-                            create<HttpHeaderAuthentication>("header")
-                        }
-                    } else {
-                        credentials {
-                            username = System.getProperty("github.packages.username") ?: System.getenv("GITHUBUSER")
-                            password = System.getProperty("github.packages.token") ?: System.getenv("GITHUBTOKEN")
-                        }
+                    name = "Snapshot"
+                    url = uri("https://artifactory.corp.code42.com/artifactory/libs-snapshot-local/")
+                    credentials {
+                        username = System.getProperty("gradle.wrapperUser")
+                        password = System.getProperty("gradle.wrapperPassword")
+                    }
+                }
+                maven {
+                    name = "Release"
+                    url = uri("https://artifactory.corp.code42.com/artifactory/libs-release-local/")
+                    credentials {
+                        username = System.getProperty("gradle.wrapperUser")
+                        password = System.getProperty("gradle.wrapperPassword")
                     }
                 }
             }
         }
     }
 }
-
-

buildSrc/build.gradle.kts

@@ -4,4 +4,4 @@ plugins {
 
 repositories {
     mavenCentral()
-}
+}

buildSrc/src/main/kotlin/com/code42/version/Version.kt

@@ -6,23 +6,23 @@ object Version {
     fun incrementVersion() {
         val versionFile = File("version.txt")
         val version = versionFile.readText()
-                .split(".")
-                .let {versionString ->
-                    val versions = versionString.mapNotNull { it.toIntOrNull() }
-                    if(versions.size != 3) {
-                        throw IllegalArgumentException("version.txt should contain a version property with 3 parts, but contained $versionString")
-                    }
-                    val major = versions[0]
-                    val minor = versions[1]
-                    val patch = versions[2] + 1
-
-                    "$major.$minor.${patch}"
+            .split(".")
+            .let { versionString ->
+                val versions = versionString.mapNotNull { it.toIntOrNull() }
+                if (versions.size != 3) {
+                    throw IllegalArgumentException("version.txt should contain a version property with 3 parts, but contained $versionString")
                 }
+                val major = versions[0]
+                val minor = versions[1]
+                val patch = versions[2] + 1
+
+                "$major.$minor.$patch"
+            }
 
         versionFile.writeText("$version")
     }
 
     fun getVersion(): String {
         return File("version.txt").readText()
     }
-}
+}

core/build.gradle.kts

@@ -0,0 +1 @@
+// Core module - no additional dependencies required