publishing.gradle

apply plugin: 'maven-publish'
apply plugin: 'signing'

def isCiBuild = System.getenv('ci_build') == 'true'
def artifactoryUsername = System.getenv('artifactory_username')
def artifactoryPassword = System.getenv('artifactory_password')
def artifactoryReleaseUrl = System.getenv('artifactory_release_url')
def artifactorySnapshotUrl = System.getenv('artifactory_snapshot_url')
def isSigningEnabled = isCiBuild
def isReleaseBuild = System.getenv('release_build') == 'true'
def sonatypeUsername = System.getenv('sonatype_username')
def sonatypePassword = System.getenv('sonatype_password')

println ">>>>>>>>> isCiBuild=${isCiBuild} isSigningEnabled=${isSigningEnabled} isReleaseBuild=${isReleaseBuild} <<<<<<<<<"

if (isSigningEnabled) {
    signing {
        project.ext["signing.keyId"] = System.getenv('signing_keyId')
        project.ext["signing.password"] = System.getenv('signing_password')
        project.ext["signing.secretKeyRingFile"] = "/tmp/secring.gpg"
    }
}

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

task javadoc(type: Javadoc) {
    failOnError false
    source = android.sourceSets.main.java.srcDirs
}

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

task signSourcesJar(type: Sign, dependsOn: sourcesJar) {
    sign sourcesJar
}

task signJavadocJar(type: Sign, dependsOn: javadocJar) {
    sign javadocJar
}

def createSignTask(def targetFile) {
    return task(type: Sign, "sign${targetFile.name.capitalize()}Output") {
        sign targetFile
    }
}

def createSignAarTask() {
    return task(type: Sign, "signAar") {
        sign bundleReleaseAar
        dependsOn bundleReleaseAar
    }
}

afterEvaluate {
publishing {
    publications {

        release(MavenPublication) {
            groupId = project.group
            version = project.android.defaultConfig.versionName + (isReleaseBuild ? "" : "-SNAPSHOT")
            artifactId = project.artifactId
            pom.packaging = 'aar'
            artifact(bundleReleaseAar) {
                classifier null
            }
            artifact javadocJar
            artifact sourcesJar
            generatePom(pom)

            if (isSigningEnabled) {
                artifact(signSourcesJar.signatureFiles.collect { it }[0]) {
                    extension 'jar.asc'
                    classifier 'sources'
                    builtBy signSourcesJar
                }
                artifact(signJavadocJar.signatureFiles.collect { it }[0]) {
                    extension 'jar.asc'
                    classifier 'javadoc'
                    builtBy signJavadocJar
                }

                def task = createSignAarTask()

                artifact(signAar.signatureFiles.collect { it }[0]) {
                    extension 'aar.asc'
                    builtBy signAar
                }

                def pomFile = new File(buildDir, "publications/" + name + "/pom-default.xml")
                task = createSignTask(pomFile)
                artifact(task.signatureFiles.collect { it }[0]) {
                    extension 'pom.asc'
                    builtBy task
                }
            }

        }
    }
    repositories {
        //https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.repositories.MavenArtifactRepository.html
        if (isCiBuild) {
            maven {
                name 'artifactory'

                credentials {
                    username artifactoryUsername
                    password artifactoryPassword
                }

                url isReleaseBuild ? artifactoryReleaseUrl : artifactorySnapshotUrl
            }

            maven {
                name = 'sonatype'

                credentials {
                    username sonatypeUsername
                    password sonatypePassword
                }

                url isReleaseBuild ? 'https://oss.sonatype.org/service/local/staging/deploy/maven2/' :
                        'https://oss.sonatype.org/content/repositories/snapshots/'

            }
        }
    }
}
}


def generatePom(def pom) {
    pom.withXml {
        asNode().appendNode('name', 'Yandex Auth SDK')
        asNode().appendNode('description', 'Yandex Auth SDK for Android')
        asNode().appendNode('url', 'https://github.com/yandexmobile/yandex-login-sdk-android')
        asNode().appendNode('developers').appendNode('developer')
                .appendNode('id', 'Yandex LLC').parent()
                .appendNode('name', 'Yandex LLC').parent()
                .appendNode('email', 'android-dev@yandex-team.ru')
        asNode().appendNode('licenses').appendNode('license')
                .appendNode('name', 'Apache License, Version 2.0').parent()
                .appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.html')
        asNode().appendNode('scm')
                .appendNode('url', 'git@github.com:yandexmobile/yandex-login-sdk-android.git').parent()
                .appendNode('connection', 'scm:git:git@github.com:yandexmobile/yandex-login-sdk-android.git').parent()
                .appendNode('developerConnection', 'scm:git:git@github.com:yandexmobile/yandex-login-sdk-android.git')

        def dependenciesNode = asNode().appendNode('dependencies')

        // List all compile dependencies and write to POM
        (configurations.implementation.getAllDependencies()
                + configurations.api.getAllDependencies()
        ).each { Dependency dep ->
            if (dep.group == null || dep.version == null || dep.name == null || dep.name == "unspecified")
                return // ignore invalid dependencies

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

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

    }
}