build.gradle

import de.materna.fegen.build.ArtifactData
import de.materna.fegen.build.license.LicensePlugin
import groovy.swing.SwingBuilder

buildscript {
    ext {
        kotlin_version = '1.4.32'

        fegen_snapshot = false
        fegen_core_version = '1.0-RC9'
        fegen_gradle_version = '1.0-RC9'
        fegen_maven_version = '1.0-RC9'
        fegen_kotlin_version = '1.0-RC9'
        fegen_kotlin_gradle_version = '1.0-RC9'
        fegen_kotlin_maven_version = '1.0-RC9'
        fegen_kotlin_runtime_version = '1.0-RC9'
        fegen_spring_util_version = '1.0-RC9'
        fegen_web_version = '1.0-RC9'
        fegen_web_gradle_version = '1.0-RC9'
        fegen_web_maven_version = '1.0-RC9'
        // Version of web runtime needs to be set in package.json

        queryPassword = { title, text ->
            def result = ""
            new SwingBuilder().edt {
                dialog(modal: true, title: title, alwaysOnTop: true, resizable: true, locationRelativeTo: null, pack: true, show: true) {
                    vbox {
                        label(text: text)
                        input = passwordField()
                        button(defaultButton: true, text: "OK", actionPerformed: {
                            result = new String(input.password)
                            dispose()
                        })
                    }
                }
            }
            if (result.isEmpty()) {
                throw new GradleException("No password specified")
            }
            return result
        }

        kotlinArtifact = { closure ->
            def data = new ArtifactData()
            closure.delegate = data
            closure()

            data.artifactProject.compileKotlin {
                kotlinOptions.jvmTarget = "1.8"
            }
            data.artifactProject.compileTestKotlin {
                kotlinOptions.jvmTarget = "1.8"
            }

            data.artifactProject.sourceCompatibility = '1.8'
            data.artifactProject.targetCompatibility = '1.8'

            def javaExt = data.artifactProject.extensions.getByName("java")
            javaExt.withJavadocJar()
            javaExt.withSourcesJar()
            data.artifactProject.publishing {
                publications {
                    mavenKotlin(MavenPublication) {
                        artifactId = data.artifactId
                        from data.artifactProject.components.java
                        pom {
                            name = data.artifactName
                            description = data.artifactDescription
                            url = "https://github.com/materna-se/fegen"
                            license {
                                name = "MIT"
                                url = "http://www.opensource.org/licenses/mit-license.php"
                            }
                            developers {
                                developer {
                                    name = "Johannes Neubauer"
                                    email = "johannes.neubauer@materna.de"
                                    organization = "Materna Information & Communications SE"
                                    organizationUrl = "https://www.materna.de"
                                }
                            }
                            scm {
                                connection = "scm:git:git://github.com/materna-se/fegen.git"
                                developerConnection = "scm:git:git://github.com/materna-se/fegen.git"
                                url = "https://github.com/materna-se/fegen/tree/master"
                            }
                        }
                    }
                }
                repositories {
                    maven {
                        def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
                        def snapshotRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots"
                        url = data.artifactProject.fegen_snapshot ? snapshotRepoUrl : releasesRepoUrl
                        if (project.ext.has("mavenCentral.username") && project.ext.has("mavenCentral.password")) {
                            credentials {
                                // The username should be stored in "$HOME/.gradle/gradle.properties"
                                username = project.ext.get("mavenCentral.username")
                                password = project.ext.getProperty("mavenCentral.password")
                            }
                        }
                    }
                }
            }
            if (project.hasProperty("signing.keyId") && project.hasProperty("signing.secretKeyRingFile")) {
                data.artifactProject.signing {
                    sign data.artifactProject.publishing.publications.mavenKotlin
                }
            }
        }

        // Use maven to generate a plugin.xml when publishing a plugin
        mavenPlugin = { Project project ->
            project.tasks.create("addPluginXml", Exec.class) {
                // Task depends on the built kotlin class files
                mustRunAfter "compileKotlin"

                // let the following task generate a pom.xml
                dependsOn "generatePomFileForMavenKotlinPublication"

                def pomDestination = new File("${project.projectDir}/pom.xml")

                // Temporarily copy the pom.xml to the project dir to make the project look like a maven project
                doFirst {
                    def pomSource = new File("${project.buildDir}/publications/mavenKotlin/pom-default.xml")
                    def pomParts = pomSource.text.split("</artifactId>")
                    pomDestination.withWriter { writer ->
                        writer.append pomParts.head() + "</artifactId>\n"
                        writer.append "  <packaging>maven-plugin</packaging>\n"
                        // This later tells maven where to read class files and where to put the plugin.xml
                        writer.append "  <build>\n"
                        writer.append "    <directory>${project.projectDir}</directory>\n"
                        writer.append "    <outputDirectory>${project.buildDir}/classes/kotlin/main</outputDirectory>\n"
                        writer.append "  </build>\n"
                        writer.append pomParts.tail().join("</artifactId>")
                    }
                    pomDestination.deleteOnExit()
                }

                def isWindows = File.separator != "/"
                def mvnw = isWindows ? "mvnw.cmd" : "mvnw"
                // Let maven generate the plugin.xml
                commandLine "${project.projectDir}/$mvnw", "-e", "-B", "org.apache.maven.plugins:maven-plugin-plugin:3.6.0:descriptor"

                doLast {
                    pomDestination.delete()
                }
            }

            // plugin.xml must be added to compiled files before jar is built
            project.assemble {
                mustRunAfter "addPluginXml"
            }

            // Task must run when any publish tasks should be run
            project.tasks.each { task ->
                if (task instanceof PublishToMavenLocal || task instanceof PublishToMavenRepository) {
                    task.dependsOn "addPluginXml"
                }
            }
        }
    }

    repositories {
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.springframework.boot:spring-boot-gradle-plugin:2.2.5.RELEASE"
    }
}

plugins {
    id "org.springframework.boot" version "2.2.4.RELEASE" apply false
    id "org.jetbrains.kotlin.jvm" version "$kotlin_version" apply false
    id "org.jetbrains.kotlin.plugin.jpa" version "$kotlin_version" apply false
    id "io.spring.dependency-management" version "1.0.10.RELEASE" apply false
}

apply plugin: 'base'
apply plugin: LicensePlugin

license {
    includes = [
            "**/src/main/**/*.kt",
            "**/src/test/**/*.kt",
            "**/src/main/**/*.java",
            "**/src/test/**/*.java",
            "**/*.swift",
            "fegen-kotlin/fegen-kotlin-android-runtime/**/*.kt",
            "fegen-web/fegen-web-runtime/src/**/*.ts",
            "fegen-examples/fegen-example-gradle/web-api/src/tests/**/*.ts",
            "fegen-examples/fegen-example-gradle/web-frontend/src/**/*.ts",
            "fegen-examples/fegen-example-gradle/web-frontend/src/**/*.tsx"
    ]
    excludes = [
            "fegen-examples/fegen-example-gradle/kotlin-api/src/main/kotlin/**/api/**/*.kt",
            "fegen-examples/fegen-example-gradle/web-frontend/src/*.ts",
            "fegen-examples/fegen-example-gradle/web-frontend/src/*.tsx",
            "fegen-examples/fegen-example-maven/kotlin-api/src/main/kotlin/**/api/**/*.kt"
    ]
}

gradle.taskGraph.whenReady { taskGraph ->
    def missingConfig = false
    if (taskGraph.allTasks.any { it instanceof PublishToMavenRepository }) {
        if (!project.ext.has("mavenCentral.username")) {
            logger.error("Please specify the property mavenCentral.username")
            logger.error("in your \"\$HOME/.gradle/gradle.properties\" file")
            missingConfig = true
        }
        if (!project.ext.has("mavenCentral.password")) {
            logger.error("Please specify the property mavenCentral.password")
            logger.error("in your \"\$HOME/.gradle/gradle.properties\" file")
            missingConfig = true
        }
    }
    if (taskGraph.allTasks.any { it instanceof Sign || (it instanceof PublishToMavenRepository && !project.ext.fegen_snapshot) }) {
        if (!project.hasProperty("signing.keyId") || !project.hasProperty("signing.secretKeyRingFile")) {
            logger.error("Please add the following properties in your \"\$HOME/.gradle/gradle.properties\" file:")
            logger.error("signing.keyId=0123ABCD")
            logger.error("signing.secretKeyRingFile=path/to/secring.gpg")
            missingConfig = true
        } else {
            def id = project.getProperties().get("signing.keyId")
            if (!project.hasProperty("signing.password")) {
                def password = queryPassword("Gradle artifact signing", "To publish artifacts they must be signed. Please enter the password for the key with ID $id")
                allprojects {
                    ext."signing.password" = password
                }
            }
        }
    }
    if (missingConfig) {
        throw new GradleException("The gradle.properties file in your home directory is missing properties. Refer to the previous log output to see which ones.")
    }
}