publish.gradle

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

def libLicense = properties.libLicense
def libLicenseUrl = properties.libLicenseUrl
def libRepositoryName = properties.libRepositoryName
def libProjectName = properties.libProjectName
def libUrl = properties.libUrl
def libVcsUrl = properties.libVcsUrl

// The note to be added at the end of the description for 'forUnitTests'
// artifacts.
def forUnitTestDescriptionSuffix =
        "This artifact is to be used for running unit tests on developer's systems."

// `jnaForTestConfiguration` is a hacky way to say yes, I'm using JNA and want
// to pack the JNA dispatch libraries and my Rust libraries into a single JAR
// for use in unit tests that run on a development host (and not an Android
// target device).  We extract the JNA libraries and our local Rust libraries
// and stick them into a JAR that consumers augment their test configuration
// with.
//
// It's only used for megazords, for which it's required. Passing it in for a
// non-megazord is allowed, but will trigger a warning.
ext.configurePublish = { jnaForTestConfiguration = null ->
    def theGroupId = rootProject.ext.library.groupId
    def theArtifactId = project.ext.artifactId
    def theDescription = project.ext.description

    task extractJnaResources(type: Sync) {
        dependsOn jnaForTestConfiguration

        from {
            // Defer the resolution of the configuration.  This helps to
            // avoid a nasty issue with the Android-Gradle plugin 3.2.1,
            // like `Cannot change attributes of configuration
            // ':PROJECT:kapt' after it has been resolved`.
            zipTree(jnaForTestConfiguration.singleFile)
        }

        into "${buildDir}/jnaResources/"

        eachFile { FileCopyDetails fcp ->
            // The intention is to just keep the various `*jnidispatch.*` files.
            if (fcp.relativePath.pathString.startsWith("META-INFO") || fcp.relativePath.pathString.endsWith(".class")) {
                fcp.exclude()
            }
        }

        includeEmptyDirs false
    }

    def forUnitTestsJarTask = task forUnitTestsJar(type: Jar) {
        from extractJnaResources
        from "$buildDir/rustJniLibs/desktop"
    }

    project.afterEvaluate {
        forUnitTestsJarTask.dependsOn(tasks["cargoBuild"])
    }

    task sourcesJar(type: Jar) {
        from android.sourceSets.main.java.srcDirs
        classifier = 'sources'
    }

    task javadoc(type: Javadoc) {
        source = android.sourceSets.main.java.srcDirs
        classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }

    publishing {
        publications {
            aar(MavenPublication) {
                project.afterEvaluate {
                    from components.findByName("androidRelease")
                }
                artifact sourcesJar
                // Can't publish Javadoc yet: Glean isn't well behaved.
                // artifact javadocJar

                // If this goes haywire with
                // 'Cannot configure the 'publishing' extension after it has been accessed.',
                // see https://github.com/researchgate/gradle-release/issues/125 and
                // https://stackoverflow.com/q/28020520.
                pom {
                    groupId = theGroupId
                    artifactId = theArtifactId
                    description = theDescription
                    version = rootProject.ext.library.version
                    packaging = "aar"

                    licenses {
                        license {
                            name = libLicense
                            url = libLicenseUrl
                        }
                    }

                    def depLicenses = new XmlSlurper().parse(new File("${projectDir}/dependency-licenses.xml"))
                    depLicenses.license.each { node ->
                        license {
                            name = node.name.text()
                            url = node.url.text()
                        }
                    }


                    developers {
                        developer {
                            name = 'Mozilla Glean Team'
                            email = 'glean-team@mozilla.com'
                        }
                    }

                    scm {
                        connection = libVcsUrl
                        developerConnection = libVcsUrl
                        url = libUrl
                    }
                }
            }

            forUnitTestsJar(MavenPublication) {
                artifact tasks['forUnitTestsJar']
                pom {
                    groupId = theGroupId
                    artifactId = "${theArtifactId}-forUnitTests"
                    description = theDescription + " " + forUnitTestDescriptionSuffix
                    version = rootProject.ext.library.version
                    packaging = "jar"

                    licenses {
                        license {
                            name = libLicense
                            url = libLicenseUrl
                        }
                    }

                    developers {
                        developer {
                            name = 'Mozilla Glean Team'
                            email = 'glean-team@mozilla.com'
                        }
                    }

                    scm {
                        connection = libVcsUrl
                        developerConnection = libVcsUrl
                        url = libUrl
                    }
                }

                pom.withXml {
                    // The 'forUnitTest' JAR, used to run unit tests on the host system,
                    // needs to declare any dependency it requires (e.g. JNA).
                    def dependenciesNode = asNode().appendNode("dependencies")
                    configurations["jnaForTest"].allDependencies.forEach {
                        if (it.group != null) {
                            def dependencyNode = dependenciesNode.appendNode("dependency")
                            dependencyNode.appendNode("groupId", it.group)
                            dependencyNode.appendNode("artifactId", it.name)
                            dependencyNode.appendNode("version", it.version)
                        }
                    }
                }

                // This is never the publication we want to use when publishing a
                // parent project with us as a child `project()` dependency.
                alias = true
            }
        }
    }
}