cloudinary_android/publish.gradle at master · dev-lcc/cloudinary_android · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
apply plugin: 'signing'
apply plugin: "de.marcphilipp.nexus-publish"
apply plugin: "io.codearte.nexus-staging"
apply plugin: 'digital.wup.android-maven-publish'

if (hasProperty("ossrhPassword")) {
    signing {
        sign configurations.archives
    }

    nexusStaging {
        packageGroup = group
        username = project.hasProperty("ossrhUsername") ? project.ext["ossrhUsername"] : ""
        password = project.hasProperty("ossrhPassword") ? project.ext["ossrhPassword"] : ""
    }

    publishing {
        publications {
            mavenAar(MavenPublication) {
                from components.android

                artifact(file("$buildDir/libs/$jarFileName-$version-javadoc.jar.asc")) {
                    classifier = 'javadoc'
                    extension = 'jar.asc'
                }

                artifact(file("$buildDir/libs/$jarFileName-$version-sources.jar.asc")) {
                    classifier = 'sources'
                    extension = 'jar.asc'
                }

                artifact(file("$buildDir/outputs/aar/$jarFileName-release.aar.asc")) {
                    classifier = null
                    extension = 'aar.asc'
                }

                pom {
                    name = publishArtifactName
                    packaging = 'aar'
                    groupId = publishGroupId
                    artifactId = publishArtifactId
                    description = publishDescription
                    url = githubUrl
                    licenses {
                        license {
                            name = licenseName
                            url = licenseUrl
                        }
                    }

                    developers {
                        developer {
                            id = developerId
                            name = developerName
                            email = developerEmail
                        }
                    }
                    scm {
                        connection = scmConnection
                        developerConnection = scmDeveloperConnection
                        url = scmUrl
                    }
                }

                pom.withXml {
                    def pomFile = file("${project.buildDir}/generated-pom.xml")
                    writeTo(pomFile)
                    def pomAscFile = signing.sign(pomFile).signatureFiles[0]
                    artifact(pomAscFile) {
                        classifier = null
                        extension = 'pom.asc'
                    }
                }

                project.tasks.signArchives.signatureFiles.each {
                    artifact(it) {
                        def matcher = it.file =~ /-(sources|javadoc)\.jar\.asc$/
                        if (matcher.find()) {
                            classifier = matcher.group(1)
                        } else {
                            classifier = null
                        }
                        extension = 'jar.asc'
                    }
                }
            }
        }

        nexusPublishing {
            repositories {
                sonatype {
                    username = project.hasProperty("ossrhUsername") ? project.ext["ossrhUsername"] : ""
                    password = project.hasProperty("ossrhPassword") ? project.ext["ossrhPassword"] : ""
                }
            }
        }

        model {
            tasks.generatePomFileForMavenAarPublication {
                destination = file("$buildDir/generated-pom.xml")
            }
            tasks.publishMavenAarPublicationToMavenLocal {
                dependsOn project.tasks.signArchives
            }
            tasks.publishMavenAarPublicationToSonatypeRepository {
                dependsOn project.tasks.signArchives
            }
        }
    }
}

task sourcesJar(type: Jar) {
    from android.sourceSets.main.java.srcDirs
    archiveClassifier = 'sources'
}
task javadoc(type: Javadoc) {
    source = android.sourceSets.main.java.srcDirs
    classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
    android.libraryVariants.all { var -> classpath += var.javaCompileProvider.get().classpath }
}
task javadocJar(type: Jar, dependsOn: javadoc) {
    archiveClassifier = 'javadoc'
    from javadoc.destinationDir
}

artifacts {
    archives javadocJar, sourcesJar
}

tasks.withType(GenerateModuleMetadata) {
    enabled = false
}