build.gradle.kts

import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import java.io.ByteArrayOutputStream
import java.time.Year

plugins {
    kotlin("jvm") version "2.1.20"
    id("org.jetbrains.dokka") version "2.0.0"
    id("org.jlleitschuh.gradle.ktlint") version "12.2.0"
    id("com.gradleup.shadow") version "8.3.6"
    id("com.github.ben-manes.versions") version "0.52.0"
    application
}

group = "com.quarkdown"

// Fetch the project version from the latest v* git tag
val lastVersionTag: String? by lazy {
    try {
        exec {
            commandLine("git", "fetch", "--tags", "-f")
        }
        val stdout = ByteArrayOutputStream()
        exec {
            commandLine("git", "describe", "--tags", "--match", "v*", "--abbrev=0")
            standardOutput = stdout
        }
        stdout.toString().trim().removePrefix("v")
    } catch (_: Exception) {
        null
    }
}

version = lastVersionTag ?: "0.0.0"

tasks.register("printVersion") {
    doLast {
        println(project.version)
    }
}

allprojects {
    repositories {
        mavenCentral()
    }
}

subprojects {
    apply(plugin = "org.jetbrains.dokka")
    apply(plugin = "org.jlleitschuh.gradle.ktlint")
}

// Fat JAR / Distribution dependencies
gradle.projectsEvaluated {
    dependencies {
        subprojects.forEach {
            when {
                it.extra.has("noRuntime") && it.extra["noRuntime"] == true -> {
                    compileOnly(it)
                }

                else -> implementation(it)
            }
        }
    }
}

application {
    mainClass.set("com.quarkdown.cli.QuarkdownCliKt")
}

ktlint {
    version.set("1.5.0")
}

// Dokka

/*dependencies {
    subprojects.forEach {
        dokka(it)
    }
}*/

dokka {
    dokkaPublications.html {
        outputDirectory.set(
            layout.buildDirectory
                .file("docs")
                .get()
                .asFile,
        )
    }
}

/**
 * Whether [project] uses the Quarkdoc plugin, which means its documentation must be included in the distribution zip.
 */
fun usesQuarkdoc(project: Project): Boolean {
    val quarkdoc = project(":quarkdown-quarkdoc")
    return project.configurations
        .asSequence()
        .flatMap { it.dependencies }
        .filterIsInstance<ProjectDependency>()
        .any { it.dependencyProject == quarkdoc }
}

tasks.register("quarkdocGenerate") {
    group = "documentation"
    description = "Generates the Quarkdoc documentation for modules that include the Quarkdoc plugin."

    dependencies {
        subprojects.filter(::usesQuarkdoc).forEach {
            dokka(it)
        }
    }

    dependsOn(tasks.dokkaGenerate)
}

tasks.register("quarkdocGenerateAll") {
    group = "documentation"
    description = "Generates the Quarkdoc documentation for all modules."

    dependencies {
        subprojects.forEach {
            dokka(it)
        }
    }

    dependsOn(tasks.dokkaGenerate)
}

allprojects {
    fun asset(path: String): File = project(":quarkdown-quarkdoc").projectDir.resolve("src/main/resources/$path")

    dokka {
        pluginsConfiguration.html {
            val year = Year.now().value
            footerMessage.set("&copy; $year Quarkdown")
            customAssets.from(*asset("assets/images").listFiles())
            customStyleSheets.from(asset("styles/stylesheet.css"))
        }
    }
}

// Tasks

tasks.build {
    dependsOn("shadowJar")
}

tasks.jar {
    enabled = false // The jar is generated by shadowJar
}

tasks.test {
    useJUnitPlatform()
    dependsOn(tasks.ktlintCheck)
}

tasks.distZip {
    val baseName = archiveBaseName.get()

    archiveVersion.set("")

    // The module 'libs' contains .qmd library files that are saved in the lib/qmd directory of the distribution zip.
    val librariesModule = project(":quarkdown-libs")

    into("$baseName/lib/qmd") {
        from(librariesModule.file("src/main/resources")) {
            include("*.qmd")
        }
    }

    // Include the generated Dokka documentation in the 'docs' directory.
    tasks.named("quarkdocGenerate").let { dokkaTask ->
        dependsOn(dokkaTask)
        val dokkaOutputDir = layout.buildDirectory.file("docs")

        from(dokkaOutputDir) {
            into("$baseName/docs")
        }
    }
}

tasks.wrapper {
    gradleVersion = "8.3"
    distributionType = Wrapper.DistributionType.ALL
}

tasks.withType<KotlinCompile> {
    compilerOptions {
        jvmTarget.set(JvmTarget.JVM_17)
    }
}

tasks.withType<ShadowJar> {
    archiveVersion.set("")
    archiveClassifier.set("")
}

tasks.withType<DependencyUpdatesTask> {
    rejectVersionIf {
        sequenceOf("alpha", "beta", "preview", "-m", "-rc").any {
            candidate.version.contains(it, ignoreCase = true)
        }
    }
}