build.gradle

import static org.gradle.jvm.toolchain.JavaLanguageVersion.of

plugins {
    id 'org.jetbrains.kotlin.jvm' apply false
    id 'org.owasp.dependencycheck' apply false
    id 'com.jfrog.artifactory'
}

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

subprojects {
    apply plugin: 'org.owasp.dependencycheck'
    apply plugin: 'idea'

    version gradle_plugins_version
    group 'net.corda.plugins'

    pluginManager.withPlugin('java') {
        java {
            toolchain {
                languageVersion = of(javaTargetVersion)
            }
        }

        pluginManager.withPlugin('java-gradle-plugin') {
            // Add a META-INF/pluginVersion.properties resource into each plugin jar.
            def generateResources = tasks.register('generateResources') {
                def versionFile = layout.buildDirectory.dir('generated').map { dir ->
                    dir.file('pluginVersion.properties')
                }

                outputs.file versionFile
                doLast {
                    versionFile.get().asFile.withWriter { out ->
                        out.println "version=${version}"
                    }
                }
            }

            tasks.named('processResources', ProcessResources) {
                from(files(generateResources)) {
                    into 'META-INF'
                }
            }

            pluginBundle {
                website = project.vcsUrl
                vcsUrl = project.vcsUrl
                tags = ['corda']

                mavenCoordinates {
                    groupId = project.group
                    artifactId = project.name
                }
            }
        }
    }

    pluginManager.withPlugin('org.jetbrains.kotlin.jvm') {
        kotlin {
            jvmToolchain {
                languageVersion = of(javaTargetVersion)
            }
        }

        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.3, but with the Kotlin 1.4 libraries.
                // Gradle 7 uses Kotlin 1.4, but with the Kotlin 1.5 libraries.
                apiVersion = '1.4'
                languageVersion = '1.4'
                freeCompilerArgs = ['-Xjvm-default=all']
            }
        }
    }

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

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

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

        doFirst {
            // 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', 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.
//  if maven.repo.s3 is set publish DP2 specific artifacts
def publishProjects = hasProperty('maven.repo.s3') ? [ project(':cordapp-cpk2')] : childProjects.values()

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

    evaluationDependsOn(subproject.path)

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

    publishing {
        publications {
            configureEach {
                pom {
                    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'
                        }
                    }
                }
            }

            register(subproject.name, MavenPublication) {
                groupId subproject.group
                artifactId subproject.name

                pluginManager.withPlugin('java') {
                    if (subproject.hasProperty('mavenArtifacts')) {
                        subproject.mavenArtifacts.call(it)
                    } else {
                        from components.java
                    }

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

                    tasks.withType(Jar)
                        .matching { it.name == 'publishPluginJavaDocsJar' }
                        .configureEach { Jar jar ->
                            jar.archiveClassifier = 'javadoc'

                            try {
                                def dokka = tasks.named('dokkaHtml')
                                jar.from dokka.flatMap { it.outputDirectory }
                            } catch (UnknownTaskException e) {
                                def javadoc = tasks.named('javadoc', Javadoc)
                                jar.from javadoc.map { it.destinationDir }
                                jar.dependsOn javadoc
                            }

                            artifact jar
                        }
                }

                pom {
                    name = subproject.name
                    description = subproject.description
                }

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

            subproject.artifactoryPublish {
                publications subproject.name
            }

            // Create a "marker" 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.
            pluginManager.withPlugin('java-gradle-plugin') {
                subproject.extensions['gradlePlugin'].plugins.configureEach { plugin ->
                    def pluginMarkerName = subproject.name + '-' + plugin.name
                    register(pluginMarkerName, MavenPublication) {
                        groupId plugin.id
                        artifactId plugin.id + '.gradle.plugin'

                        pom {
                            name = "Gradle plugin marker for ${plugin.id}"
                            description = subproject.description
                            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)
                            }
                        }
                    }

                    subproject.artifactoryPublish {
                        publications pluginMarkerName
                    }
                }
            }
        }
        if (subproject.hasProperty('maven.repo.s3')) {
            repositories {
                maven {
                    name = 'AWS'
                    url = subproject.findProperty('maven.repo.s3')
                    credentials(AwsCredentials) {
                        accessKey "${System.getenv('AWS_ACCESS_KEY_ID')}"
                        secretKey "${System.getenv('AWS_SECRET_ACCESS_KEY')}"
                        sessionToken "${System.getenv('AWS_SESSION_TOKEN')}"
                    }
                }
            }
        }
    }
}

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

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