maven-publish.gradle

/*
 * Copyright 2020 ZUP IT SERVICOS EM TECNOLOGIA E INOVACAO SA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

apply plugin: 'com.github.dcendents.android-maven'
apply plugin: 'maven-publish'
apply from: rootProject.file('dokka.gradle')

def versionName = System.env.VERSION_DEPLOY != null ? System.env.VERSION_DEPLOY : VERSION_NAME ?: ""
group = GROUP_NAME
version = versionName

ext {
    localProp = new Properties()
    fileName = 'local.properties'
    if (project.rootProject.file(fileName).exists()) {
        localProp.load(new FileInputStream(rootProject.file(fileName)))
    }
    publishUsername = System.env.NX_USR_SNP != null ? System.env.NX_USR_SNP : localProp["publishUsername"] ?: ""
    publishPassword = System.env.NX_PSS_SNP != null ? System.env.NX_PSS_SNP : localProp["publishPassword"] ?: ""
    destinationRepoUrl = System.env.NX_REPO_URL != null ? System.env.NX_REPO_URL : localProp["destinationRepoUrl"] ?: ""
}

install {
    repositories.mavenInstaller {
        pom.project {
            packaging 'jar'
            groupId GROUP_NAME
            artifactId ARTIFACT_NAME

            name GROUP_NAME
            description DESCRIPTION
            url SITE_URL

            licenses {
                license {
                    name LICENCE_NAME
                    url LICENCE_URL
                }
            }
            developers {
                developer {
                    id DEVELOPER_ID
                    name DEVELOPER_NAME
                    email DEVELOPER_EMAIL
                }
            }
            scm {
                connection GIT_URL
                developerConnection GIT_URL
                url SITE_URL
            }
            def deps = configurations.compile.allDependencies + configurations.implementation.allDependencies
            deps.each {
                dependencies.add("compile", it)
            }
        }
    }
}

if (project.hasProperty("android")) { // Android libraries
    task sourcesJar(type: Jar) {
        classifier = 'sources'
        from android.sourceSets.main.java.srcDirs
    }

    task javadoc(type: Javadoc) {
        source = android.sourceSets.main.java.srcDirs
        classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
    }
    task javadocJar(type: Jar, dependsOn: dokka) {
        classifier = 'javadoc'
        from "$buildDir/javadoc"
    }
} else { // Java libraries
    task sourcesJar(type: Jar, dependsOn: classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    task javadocJar(type: Jar, dependsOn: dokka) {
        classifier = 'javadoc'
        from "$buildDir/javadoc"
    }
}

project.afterEvaluate {
    publishing {

        repositories {
            maven {
                credentials {
                    username publishUsername
                    password publishPassword
                }
                url destinationRepoUrl
            }
        }

        publications {

            maven(MavenPublication) {
                artifactId ARTIFACT_NAME
                groupId GROUP_NAME
                version versionName

                if (project.hasProperty("android")) {
                    artifact bundleReleaseAar
                } else {
                    from components.java
                }

                artifact javadocJar
                artifact sourcesJar

                if (project.hasProperty("android")) {
                    pom.withXml {
                        final dependenciesNode = asNode().appendNode('dependencies')

                        ext.addDependency = { dep, String scope ->
                            if (dep.group == null || dep.version == null || dep.name == null || dep.name == "unspecified" || dep.name == "beagle")
                                return // ignore invalid dependencies

                            final dependencyNode = dependenciesNode.appendNode('dependency')
                            dependencyNode.appendNode('groupId', dep.group)
                            dependencyNode.appendNode('artifactId', dep.name)
                            dependencyNode.appendNode('version', dep.version)
                            dependencyNode.appendNode('scope', scope)

                            if (!dep.transitive) {
                                // If this dependency is not transitive, we should force exclude all its dependencies from the POM
                                final exclusionNode = dependencyNode.appendNode('exclusions').appendNode('exclusion')
                                exclusionNode.appendNode('groupId', '*')
                                exclusionNode.appendNode('artifactId', '*')
                            } else if (!dep.properties.excludeRules.empty) {
                                // Otherwise add specified exclude rules
                                final exclusionsNode = dependencyNode.appendNode('exclusions')
                                dep.properties.excludeRules.each { rule ->
                                    final exclusionNode = exclusionsNode.appendNode('exclusion')
                                    exclusionNode.appendNode('groupId', rule.group ?: '*')
                                    exclusionNode.appendNode('artifactId', rule.module ?: '*')
                                }
                            }
                        }

                        // List all "api" dependencies (for new Gradle) as "compile" dependencies
                        configurations.api.getDependencies().each { dep -> addDependency(dep, "compile") }
                        // List all "implementation" dependencies (for new Gradle) as "runtime" dependencies
                        configurations.implementation.getDependencies().each { dep -> addDependency(dep, "runtime") }
                    }
                }
            }
        }
    }
}