application-services/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

ext.configurePublish = { groupIdArg, artifactIdArg, descriptionArg,
                         jnaForTestConfiguration = null,
                         variantWithoutLib = null ->
    // `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.
    //
    // `variantWithoutLib` says to publish an AAR that doesn't have native Rust
    // libraries packed into it.  Such an AAR will be aggregated into another
    // Maven publication that has a single megazord Rust library that provides
    // the native code functionality.
    if (jnaForTestConfiguration != null) {
        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: fxaclient 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 = groupIdArg
                    artifactId = artifactIdArg
                    description = descriptionArg
                    version = rootProject.ext.library['version']

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

                    developers {
                        developer {
                            name = 'Mozilla Application Services'
                            email = 'application-services@mozilla.com'
                        }
                    }

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

                if (variantWithoutLib != null) {
                    // If we are publishing a `-withoutLib` publication, we
                    // never want to choose the real one when a parent project
                    // has us as a child `project()` dependency.
                    alias = true
                }
            }

            if (variantWithoutLib != null) {
                aarWithoutLib(MavenPublication) {
                    project.afterEvaluate {
                        from components.findByName(variantWithoutLib)
                    }
                    artifact sourcesJar
                    // Can't publish Javadoc yet: fxaclient isn't well behaved.
                    // artifact javadocJar

                    pom {
                        groupId = groupIdArg
                        artifactId = "${artifactIdArg}-withoutLib"
                        description = descriptionArg
                        version = rootProject.ext.library['version']

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

                        developers {
                            developer {
                                name = 'Mozilla Application Services'
                                email = 'application-services@mozilla.com'
                            }
                        }

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

            if (jnaForTestConfiguration != null) {
                forUnitTestsJar(MavenPublication) {
                    artifact tasks['forUnitTestsJar']

                    pom {
                        groupId = groupIdArg
                        artifactId = "${artifactIdArg}-forUnitTests"
                        description = descriptionArg
                        version = rootProject.ext.library['version']

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

                        developers {
                            developer {
                                name = 'Mozilla Application Services'
                                email = 'application-services@mozilla.com'
                            }
                        }

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

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

    apply plugin: 'com.jfrog.bintray'

    // It feels like this shouldn't be necessary, but without it an
    // "unspecified" creeps into bintray URLs -- just like
    // https://github.com/bintray/gradle-bintray-plugin/issues/244, but not
    // fixed by gradle-bintray-plugin:1.8.4.
    version = rootProject.ext.library['version']

    Properties localProperties = null;
    if (project.rootProject.file('local.properties').canRead()) {
        localProperties = new Properties()
        localProperties.load(project.rootProject.file('local.properties').newDataInputStream())
    }

    def thePublications = ['aar']
    if (variantWithoutLib != null) {
        thePublications << 'aarWithoutLib'
    }
    if (jnaForTestConfiguration != null) {
        thePublications << 'forUnitTestsJar'
    }

    bintray {
        user = localProperties != null ? localProperties.getProperty("bintray.user") : ""
        key = localProperties != null ? localProperties.getProperty("bintray.apikey") : ""

        publications = thePublications

        pkg {
            repo = libRepositoryName
            name = libProjectName
            websiteUrl = libUrl
            vcsUrl = libVcsUrl
            if (project.ext.has('vcsTag')) {
                vcsTag = project.ext.vcsTag
            }
            licenses = [libLicense]
            publish = true
            publicDownloadNumbers = true
        }
    }

    task zipMavenArtifacts(type: Zip) {
        from "${project.buildDir}/maven"

        include '**/*.aar'
        include '**/*.jar'
        include '**/*.pom'
        include '**/*.md5'
        include '**/*.sha1'

        // Metadata is generated by maven.mozilla.org directly
        exclude '**/*maven-metadata.xml*'

        archiveName "target.maven.zip"
        includeEmptyDirs = false
        destinationDir(file("${project.buildDir}"))
    }
}