build.gradle

// Load plugin dependencies and initialize build variables.
buildscript {
    ext {
        // Version used for submodule artifacts.
        // Snapshot publishing changes (or adds) the suffix after '-' with 'SNAPSHOT' prior to publishing.
        globalVersion = '1.2.1'
        clientsVersion = '1.2.1-alpha.1' // The clients subsystem is still expected to change drastically.

        versions = [
            // Kotlin multiplatform versions.
            kotlin:'1.9.23',
            serialization:'1.6.3',
            coroutines:'1.8.0',
            datetime:'0.5.0',

            // JVM versions.
            jvmTarget:'1.8',
            dokkaPlugin:'1.9.20',
            reflections:'0.10.2',

            // JS versions.
            nodePlugin:'7.0.2',
            bigJs:'6.2.1',

            // DevOps versions.
            detektPlugin:'1.23.5',
            detektVerifyImplementation:'1.2.5',
            nexusPublishPlugin:'1.3.0',
            apacheCommons:'2.15.1'
        ]

        commonModule = subprojects.find { it.name == 'carp.common' }
        coreModules = subprojects.findAll { it.name.endsWith( '.core' ) }
        testModules = subprojects.findAll { it.name == 'carp.common.test' || it.name == 'carp.test' }
        publishNpmModule = subprojects.find { it.name == 'publish-npm-packages' }
        allModules = coreModules + testModules + commonModule + publishNpmModule
        devOpsModules =
            subprojects.findAll {it.name == 'carp.detekt' || it.name == 'rpc' } + publishNpmModule
    }

    dependencies {
        // Kotlin plugins.
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
        classpath "org.jetbrains.kotlin:kotlin-serialization:${versions.kotlin}"

        // JS plugins.
        classpath "com.github.node-gradle:gradle-node-plugin:${versions.nodePlugin}"

        // JVM plugins.
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:${versions.dokkaPlugin}"

        // DevOps plugins.
        classpath "io.gitlab.arturbosch.detekt:detekt-gradle-plugin:${versions.detektPlugin}"
        classpath "io.github.gradle-nexus:publish-plugin:${versions.nexusPublishPlugin}"
    }

    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
}

// Load dependent properties.
def publishProperties = new Properties()
def publishPropertiesFile = rootProject.file('publish.properties')
if (publishPropertiesFile.exists())
{
    publishProperties.load(new FileInputStream(publishPropertiesFile))
}

// Configure all subprojects as testable, publishable, Kotlin multiplatform projects.
// A `kotlinx.serialization` dependency is added to serialize domain models.
// A `kotlinx-datetime` dependency is added to be able to store dates in domain models.
configure( subprojects - devOpsModules ) {
    version = globalVersion

    // Specify platforms and test frameworks to use.
    apply plugin: 'kotlin-multiplatform'
    apply plugin: 'kotlinx-serialization'
    kotlin {
        jvm {
            compilations.main.kotlinOptions.jvmTarget = versions.jvmTarget
            compilations.test.kotlinOptions.jvmTarget = versions.jvmTarget

            testRuns["test"].executionTask.configure {
                useJUnitPlatform()
            }
        }
        js(IR) {
            moduleName = project.name.replaceAll("\\.", "-") + "-generated"
            binaries.executable() // Export JS/TypeScript files.
            browser()
            generateTypeScriptDefinitions()
        }

        targets.configureEach {
            compilations.configureEach {
                def isTestSourceSet = it.name == 'test'

                compilerOptions.configure((Action) {
                    // Treat compilation warning as errors for all compilation targets.
                    it.allWarningsAsErrors = true

                    // We do not mind being early adopters of Jetbrains APIs likely to change in the future.
                    it.optIn.add('kotlin.RequiresOptIn')
                    it.optIn.add('kotlin.time.ExperimentalTime')
                    it.optIn.add('kotlin.js.ExperimentalJsExport')
                    if (isTestSourceSet)
                    {
                        it.optIn.add('kotlinx.coroutines.ExperimentalCoroutinesApi')
                    }
                    it.freeCompilerArgs.add('-Xexpect-actual-classes') // https://youtrack.jetbrains.com/issue/KT-61573
                } )
            }
        }

        sourceSets {
            commonMain {
                dependencies {
                    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:${versions.serialization}"
                    api "org.jetbrains.kotlinx:kotlinx-datetime:${versions.datetime}"
                }
            }
            commonTest {
                dependencies {
                    implementation kotlin('test')
                    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:${versions.coroutines}"
                }
            }
            jvmTest {
                dependencies {
                    implementation kotlin('reflect')
                    implementation "org.reflections:reflections:${versions.reflections}"
                }
            }
        }
    }

    // Publish configuration.
    // For signing and publishing to work, a 'publish.properties' file needs to be added to the root containing:
    // The OpenPGP credentials to sign all artifacts:
    // > signing.keyFile=<ABSOLUTE PATH TO THE ASCII-ARMORED KEY FILE>
    // > signing.password=<SECRET>
    // A username and password to upload artifacts to the Sonatype repository:
    // > repository.username=<SONATYPE USERNAME>
    // > repository.password=<SONATYPE PASSWORD>
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: 'org.jetbrains.dokka'
    task dokkaJvmJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
        dokkaSourceSets {
            register("jvm") {
                platform.set(org.jetbrains.dokka.Platform.jvm)
                sourceRoots.from(kotlin.sourceSets.getByName("jvmMain").kotlin.srcDirs)
            }
        }
    }
    task javadocJar(type: Jar) {
        group JavaBasePlugin.DOCUMENTATION_GROUP
        description 'Create javadoc jar using Dokka'
        archiveClassifier = "javadoc"
        from dokkaJvmJavadoc
    }
    publishing {
        publications {
            all {
                pom {
                    url = 'https://github.com/cph-cachet/carp.core-kotlin'
                    licenses {
                        license {
                            name = 'MIT License'
                            url = 'https://github.com/cph-cachet/carp.core-kotlin/blob/master/LICENSE.md'
                        }
                    }
                    developers {
                        developer {
                            id = 'whathecode'
                            name = 'Steven Jeuris'
                            email = 'steven.jeuris@gmail.com'
                            organization = 'CACHET'
                            organizationUrl = 'http://www.cachet.dk/'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/cph-cachet/carp.core-kotlin.git'
                        developerConnection = 'scm:git:ssh://github.com:cph-cachet/carp.core-kotlin.git'
                        url = 'https://github.com/cph-cachet/carp.core-kotlin'
                    }
                }
            }
            jvm {
                artifact javadocJar
            }
        }
        repositories {
            maven {
                name "local"
                url "$buildDir/repository"
            }
        }
    }
    signing {
        def signingKeyFile = publishProperties['signing.keyFile']
        if (signingKeyFile != null) {
            def signingKey = new File(signingKeyFile).text
            def signingPassword = publishProperties['signing.password']
            useInMemoryPgpKeys(signingKey, signingPassword)
            sign publishing.publications
        }
    }
}

// Sonatype Nexus publication.
apply plugin: 'io.github.gradle-nexus.publish-plugin'
group = "dk.cachet.carp"
version = globalVersion
nexusPublishing {
    repositories {
        sonatype {
            username = publishProperties['repository.username']
            password = publishProperties['repository.password']
        }
    }
}
task setSnapshotVersion {
    doFirst {
        def versionSplit = globalVersion.split('-')
        def snapshotVersion = "${versionSplit[0]}-SNAPSHOT"
        version = snapshotVersion

        (rootProject.subprojects - devOpsModules).each { project ->
            project.version = snapshotVersion
        }
    }
}

// TypeScript ambient declaration verification.
def typescriptFolder = 'typescript-declarations'
def npmScope = "@cachet"
apply plugin: 'com.github.node-gradle.node'
task setupTsProject(type: NpmTask) {
    workingDir = file(typescriptFolder)
    args = ['install']
}
task copyTestJsSources(type: Copy, dependsOn: setupTsProject) {
    // Compile production sources for CARP, and the JS publication project (`publishNpmModule`).
    allModules.each {
        def project = it.name
        dependsOn("$project:jsProductionExecutableCompileSync")
    }

    // Copy compiled JS and TypeScript sources to test project's node_modules.
    from("$rootDir/build/js/packages/publish-npm-packages-generated") {
        include "**/*.js"
    }
    from("$rootDir/build/js/packages") {
        // Use individually generated TypeScript declarations to exclude publish-npm-packages exports.
        include "**/*.d.ts"
        includeEmptyDirs = false
    }
    eachFile { file ->
        // Compiled sources have the name of the module they represent, followed by ".js" and ".d.ts".
        // To be recognized by node, place them as "index.js" and "index.d.ts" in "node_modules/<scope>/<module-name>".
        def fileMatch = file.name =~ /(.+)\.(js|d\.ts)/
        def moduleName = fileMatch[0][1]
        def extension = fileMatch[0][2]
        file.relativePath = new RelativePath(true, moduleName, "index.$extension")

        // Non-exported types show up as `any/* some.unknown.Type */` in generated TypeScript sources.
        // Types for which a facade has been manually added can be replaced with the actual type (instead of `any`).
        def knownFacadeTypes = []
        def knownFacadeTypesFile = new File("$rootDir/publish-npm-packages/src/known-facade-types")
        knownFacadeTypesFile.eachLine { type -> knownFacadeTypes << type }

        // Modify sources to act like modules with exported named members.
        file.filter { line ->
            // Compiled sources refer to other modules as adjacent .js source files.
            // Change these to the scoped modules created in the previous step.
            def namedModules = line.replaceAll(~/'\.\/(.+?)\.js'/, "'$npmScope/\$1'")

            // Replace `any` types with actual types for which facades are specified.
            def replacedTypes = knownFacadeTypes.inject(namedModules) { curLine, type ->
                def knownType = curLine.replaceAll(
                    ~/any\/\* $type(<.+?>)? \*\//,
                    "$type\$1"
                )
                knownType.replaceAll(~/UnknownType \*/, "any")
            }

            // Add additional internal types to be exported, as configured in `forced-exports`.
            def toExport = []
            def forcedExportsFile = new File("$rootDir/publish-npm-packages/src/forced-exports/$moduleName")
            if (forcedExportsFile.exists()) {
                forcedExportsFile.eachLine { type -> toExport << type }
            }
            def toExportList = toExport.collect { "_.\\\$_\\\$.$it = $it\n  " }
            def additionalExports = replacedTypes.replaceAll(
                ~/return \_;/,
                toExportList.join() + "return _;"
            )
            additionalExports
        }
    }
    into "./$typescriptFolder/node_modules/$npmScope/"
}
task packageTestJsSources(type: Copy, dependsOn: copyTestJsSources) {
    allModules.each {
        def project = it.name
        dependsOn("$project:jsPackageJson")
        dependsOn("$project:jsTestPackageJson")
    }

    from("$rootDir/build/js/packages") {
        include "**/package.json"
        includeEmptyDirs = false
    }
    eachFile { file ->
        def moduleName = file.getFile().getParentFile().name
        file.filter { line ->
            // Add scope to module name.
            def changedName = line.replaceAll(~/("name": ).*/, "\$1 \"$npmScope/$moduleName\",")

            // Point main source to 'index.js'.
            changedName.replaceAll(~/("main": ).*/, "\$1 \"index.js\",")
        }

    }
    into "./$typescriptFolder/node_modules/$npmScope/"
}
task compileTs(type: NpmTask, dependsOn: packageTestJsSources) {
    workingDir = file(typescriptFolder)
    args = ['run', 'tsc']
}
task verifyTsDeclarations(type: NodeTask, dependsOn: compileTs) {
    script = file("${typescriptFolder}/node_modules/mocha/bin/mocha.js")
    execOverrides {
        it.workingDir = typescriptFolder
    }
}

// Add `carp.test` helpers.
configure( coreModules + commonModule ) {
    kotlin {
        sourceSets {
            commonTest {
                dependencies {
                    implementation project(':carp.test')
                }
            }
        }
    }
}


// Add dependencies of all core modules on `carp.common`.
configure( coreModules ) {
    kotlin {
        sourceSets {
            commonMain {
                dependencies {
                    api project(':carp.common')
                }
            }
            commonTest {
                dependencies {
                    implementation project(':carp.common.test')
                }
            }
        }
    }
}


// Add code analysis.
configure( rootProject )
{
    apply plugin: 'io.gitlab.arturbosch.detekt'
    detekt {
        dependencies {
            detektPlugins "io.gitlab.arturbosch.detekt:detekt-formatting:${versions.detektPlugin}"
            detektPlugins project(":carp.detekt") // Add custom project-specific rules.
            detektPlugins "dk.cachet.detekt.extensions:detekt-verify-implementation:${versions.detektVerifyImplementation}"
        }
    }
    task detektPasses(type: io.gitlab.arturbosch.detekt.Detekt) {
        source = fileTree("$rootDir")
        {
            include('**/src/**')
            exclude('**/node_modules/**', '**/resources/**')
        }
        config.from("$rootDir/detekt.yml")
        buildUponDefaultConfig = true
        ignoreFailures = false
        def classPaths = project.configurations.getByName("detekt")
        def multiplatformModules = coreModules + commonModule
        multiplatformModules.each { classPaths += it.configurations.getByName("jvmCompileClasspath") }
        classpath.setFrom(classPaths)
    }
    tasks.detekt.jvmTarget = "1.8"
    tasks.detekt.dependsOn ":carp.detekt:assemble" // Ensure 'carp.detekt' is built prior to running code analysis.
}