gradle-mvn-push.gradle

/*
 * Copyright 2013 Chris Banes
 *
 * 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: 'maven-publish'
apply plugin: 'signing'
apply plugin: 'com.github.johnrengelman.shadow'

version = VERSION_NAME
group = GROUP

afterEvaluate { project ->
    if (isAndroidProject(project)) {
        android.libraryVariants.matching { it.name == "release" }.each { releaseVariant ->
            tasks.register('javadocs', Javadoc) {
                dependsOn 'assembleRelease'
                source = android.sourceSets.main.java.source
                classpath += project.files(
                        files(releaseVariant.javaCompileProvider.get().classpath),
                        project.android.getBootClasspath().join(File.pathSeparator),
                        files("$buildDir/intermediates/classes/release"),
                        files("$buildDir/generated/ap_generated_sources/release/out"),
                        files("$project.rootProject.rootDir/dagger-library-shadow/build/libs/dagger-library-shadow-${project.version}.jar")
                )
                title = null
                options.noTimestamp(false)
            }
        }
    } else {
        tasks.register('javadocs', Javadoc) {
            source = sourceSets.main.java.classesDirectory
            classpath += configurations.compileClasspath
            title = null
            options.noTimestamp(false)
        }
    }
    tasks.register('javadocsJar', Jar) {
        dependsOn javadocs
        archiveClassifier.set('javadoc')
        from javadocs.destinationDir
    }

    tasks.register('sourcesJar', Jar) {
        archiveClassifier.set('sources')
        if (isAndroidProject(project)) {
            from android.sourceSets.main.java.source
        } else {
            from sourceSets.main.allSource
        }
    }
    publishing {
        publications {
            release(MavenPublication) { publication ->
                afterEvaluate {
                    groupId = GROUP
                    artifactId = POM_ARTIFACT_ID
                    version = VERSION_NAME
                    if (project.tasks.findByName('shadowJar')) {
                        project.shadow.component(publication)
                    } else {
                        from isAndroidProject(project) ? components.release : components.java
                    }
                    artifact sourcesJar
                    artifact javadocsJar
                    pom {
                        name = POM_NAME
                        description = POM_DESCRIPTION
                        url = POM_URL
                        packaging = POM_PACKAGING
                        licenses {
                            license {
                                name = POM_LICENCE_NAME
                                url = POM_LICENCE_URL
                                distribution = POM_LICENCE_DIST
                            }
                        }
                        developers {
                            developer {
                                id = POM_DEVELOPER_ID
                                name = POM_DEVELOPER_NAME
                            }
                        }
                        scm {
                            url = POM_SCM_URL
                            connection = POM_SCM_CONNECTION
                            developerConnection = POM_SCM_DEV_CONNECTION
                        }
                    }
                }
            }
        }
    }

    signing {
        required { isReleaseBuild() && gradle.taskGraph.hasTask("uploadArchives") }
        useInMemoryPgpKeys(getSigningKey(), getSigningKeyPassword())
        sign(publishing.publications.release)
    }
}