build.gradle

import static org.gradle.api.JavaVersion.VERSION_1_8
import static org.gradle.jvm.toolchain.JavaLanguageVersion.of

plugins {
    id 'org.jetbrains.kotlin.jvm' apply false
    id 'com.gradle.plugin-publish' apply false
    id 'com.jfrog.artifactory' apply false
    id 'com.jfrog.bintray' apply false
}

ext {
    vcsUrl = 'https://github.com/corda/corda-gradle-plugins'
}

subprojects {
    apply plugin: 'java-library'
    apply plugin: 'idea'

    version gradle_plugins_version
    group 'net.corda.plugins'

    java {
        toolchain {
            languageVersion = of(8)
        }
    }

    tasks.withType(JavaCompile).configureEach {
        options.encoding = 'UTF-8'
    }

    tasks.withType(GroovyCompile).configureEach {
        options.encoding = 'UTF-8'
    }

    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
        kotlinOptions {
            // When writing Gradle plugins in Kotlin, we need to restrict
            // ourselves to the same Kotlin API that Gradle itself uses.
            // Gradle 4.10.x uses Kotlin 1.2.
            // Gradle 5.x - 6.7.1 uses Kotlin 1.3.
            // Gradle 6.8 uses Kotlin 1.4
            jvmTarget = VERSION_1_8
            apiVersion = '1.3'
            languageVersion = '1.3'
            freeCompilerArgs = ['-Xjvm-default=enable']
        }
    }

    tasks.withType(Test).configureEach {
        useJUnitPlatform()

        // Prevent the project from creating temporary files outside of the build directory.
        systemProperty 'java.io.tmpdir', buildDir.absolutePath

        // Tell the tests where Gradle's current module cache is.
        // We need the tests to share this module cache to prevent the
        // Gradle Test-Kit from downloading its own copy of Kotlin etc.
        systemProperty 'test.gradle.user.home', project.gradle.gradleUserHomeDir
    }

    tasks.withType(ValidatePlugins).configureEach {
        // Ask Gradle to tell us how to annotate tasks correctly.
        enableStricterValidation = true
    }

    tasks.withType(GenerateModuleMetadata).configureEach {
        enabled = false
    }

    idea {
        module {
            downloadJavadoc = true
            downloadSources = true
        }
    }
}

// Only the top-level projects are plugins, so only publish these ones.
// The "child projects" are the immediate children of the root. Any
// "grandchild" project is considered to be internal to its parent.
def publishProjects = project.childProjects.values()

configure(publishProjects) { Project subproject ->
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.bintray'
    apply plugin: 'com.jfrog.artifactory'
    apply plugin: 'com.gradle.plugin-publish'

    evaluationDependsOn(subproject.path)

    tasks.register('sourceJar', Jar) {
        dependsOn subproject.classes
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

    tasks.register('javadocJar', Jar) {
        dependsOn subproject.javadoc
        archiveClassifier = 'javadoc'
        from javadoc.destinationDir
    }

    tasks.register('install') {
        dependsOn 'publishToMavenLocal'
    }

    publishing {
        publications {
            create(subproject.name, MavenPublication) {
                if (subproject.hasProperty('mavenArtifacts')) {
                    subproject.mavenArtifacts.call(it)
                } else {
                    from components.java
                }

                groupId subproject.group
                artifactId subproject.name
                artifact tasks.sourceJar
                artifact tasks.javadocJar

                pom {
                    name = subproject.name
                    description = subproject.description
                    url = vcsUrl
                    scm {
                        url = vcsUrl
                    }

                    licenses {
                        license {
                            name = 'Apache-2.0'
                            url = 'https://www.apache.org/licenses/LICENSE-2.0'
                            distribution = 'repo'
                        }
                    }

                    developers {
                        developer {
                            id = 'R3'
                            name = 'R3'
                            email = 'dev@corda.net'
                        }
                    }
                }

                if (subproject.hasProperty('mavenPom')) {
                    subproject.mavenPom.call(pom)
                }
            }

            // Create a "special" artifact in the Maven repository so that
            // Gradle's plugins {} block can find our plugins:
            //
            // This artifact would normally be created by setting:
            //
            //     gradlePlugin {
            //         automatedPublishing = true
            //     }
            //
            // except that this would also discard all of our POM customisations.
            subproject.extensions['gradlePlugin'].plugins.forEach { plugin ->
                create(subproject.name + '-' + plugin.name, MavenPublication) {
                    groupId plugin.id
                    artifactId plugin.id + '.gradle.plugin'

                    pom {
                        packaging 'pom'
                        withXml {
                            def dependency = asNode().appendNode('dependencies').appendNode('dependency')
                            dependency.appendNode('groupId', subproject.group)
                            dependency.appendNode('artifactId', subproject.name)
                            dependency.appendNode('version', subproject.version)
                        }
                    }
                }
            }
        }
    }

    bintray {
        user = System.getenv('CORDA_BINTRAY_USER') ?: System.getProperty('corda.bintray.user')
        key = System.getenv('CORDA_BINTRAY_KEY') ?: System.getProperty('corda.bintray.key')
        publications = [subproject.name]
        dryRun = (System.getenv('CORDA_BINTRAY_DRYRUN') != null || System.getProperty('corda.bintray.dryrun') != null)
        pkg {
            repo = 'corda'
            name = subproject.name
            userOrg = 'r3'
            licenses = ['Apache-2.0']

            version {
                gpg {
                    sign = true
                    passphrase = System.getenv('CORDA_BINTRAY_GPG_PASSPHRASE')
                }
            }
        }
    }
}

artifactory {
    publish {
        contextUrl = artifactory_contextUrl
        repository {
            repoKey = 'corda-dev'
            username = project.findProperty('cordaArtifactoryUsername') ?: System.getenv('CORDA_ARTIFACTORY_USERNAME') ?: System.getProperty('corda.artifactory.username')
            password = project.findProperty('cordaArtifactoryPassword') ?: System.getenv('CORDA_ARTIFACTORY_PASSWORD') ?: System.getProperty('corda.artifactory.password')
        }

        defaults {
            if (publishProjects.contains(project)) {
                publications(project.name)

                project.extensions['gradlePlugin'].plugins.forEach { plugin ->
                    publications(project.name + '-' + plugin.name)
                }
            }
        }
    }
}

wrapper {
    gradleVersion = '6.7.1'
    distributionType = Wrapper.DistributionType.ALL
}