common_publish.gradle

def versionProperties = new Properties()
versionProperties.load(new FileInputStream(rootProject.file("version.properties")))

ext.versionCode = versionProperties.getProperty("versionCode").toInteger()
ext.versionName = versionProperties.getProperty("versionName")

def privateProperties = new Properties()
def privatePropertiesFile = rootProject.file("private.properties")
if (privatePropertiesFile.exists()) {
    privateProperties.load(new FileInputStream(rootProject.file("private.properties")))
} else {
    privateProperties.setProperty("githubUser", System.getenv("PUBLISH_GITHUB_USER") ?: "MISSING")
    privateProperties.setProperty("githubToken", System.getenv("PUBLISH_GITHUB_TOKEN") ?: "MISSING")

    privateProperties.setProperty("sonatypeUser", System.getenv("PUBLISH_SONATYPE_USER") ?: "MISSING")
    privateProperties.setProperty("sonatypePassword", System.getenv("PUBLISH_SONATYPE_PASSWORD") ?: "MISSING")

    privateProperties.setProperty("signingKeyId", System.getenv("PUBLISH_SIGNING_KEY_ID") ?: "MISSING")
    privateProperties.setProperty("signingKeyPassword", System.getenv("PUBLISH_SIGNING_KEY_PASSWORD") ?: "MISSING")
    privateProperties.setProperty("signingKeyLocation", System.getenv("PUBLISH_SIGNING_KEY_LOCATION") ?: "MISSING")
}

ext.publishAndroidModule = { String groupName, String moduleName, String versionSuffix = "" ->
    publishModule(true, groupName, moduleName, versionSuffix)
}

ext.publishJavaModule = { String groupName, String moduleName, String versionSuffix = "" ->
    publishModule(false, groupName, moduleName, versionSuffix)
}

ext.publishModule = { Boolean isAndroid, String groupName, String moduleName, String versionSuffix = "" ->
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    ext["signing.keyId"] = privateProperties['signingKeyId']
    ext["signing.password"] = privateProperties['signingKeyPassword']
    ext["signing.secretKeyRingFile"] = privateProperties['signingKeyLocation']

    if(isAndroid) {
        task androidSourcesJar(type: Jar) {
            archiveClassifier.set('sources')
            from android.sourceSets.main.java.srcDirs
        }

        artifacts {
            archives androidSourcesJar
        }
    }
    else {
        javadoc {
            source = sourceSets.main.allJava
            classpath = configurations.compileClasspath
            options {
                setMemberLevel JavadocMemberLevel.PUBLIC
                setAuthor true
                links "https://docs.oracle.com/javase/8/docs/api/"
            }
        }
        task sourcesJar(type: Jar) {
            archiveClassifier.set('sources')
            from sourceSets.main.java.srcDirs
        }
        task javadocJar(type: Jar) {
            archiveClassifier.set('javadoc')
            from javadoc
        }
        artifacts {
            archives sourcesJar
            archives javadocJar
        }
    }

    afterEvaluate {
        group = groupName
        version = versionName + versionSuffix

        publishing {
            publications {
                release(MavenPublication) {
                    if(isAndroid) {
                        from components.release
                    }
                    else {
                        from components.java
                    }

                    groupId groupName
                    artifactId moduleName
                    version versionName + versionSuffix

                    if(isAndroid) {
                        artifact androidSourcesJar
                    }
                    else {
                        artifact sourcesJar
                        artifact javadocJar
                    }

                    pom {
                        name = moduleName
                        description = "A component of Enro, a small navigation library for Android"
                        url = "https://github.com/isaac-udy/Enro"
                        licenses {
                            license {
                                name = 'Enro License'
                                url = 'https://github.com/isaac-udy/Enro/blob/main/LICENSE'
                            }
                        }
                        developers {
                            developer {
                                id = 'isaac.udy'
                                name = 'Isaac Udy'
                                email = 'isaac.udy@gmail.com'
                            }
                        }
                        scm {
                            connection = 'scm:git:github.com/isaac-udy/Enro.git'
                            developerConnection = 'scm:git:ssh://github.com/isaac-udy/Enro.git'
                            url = 'https://github.com/isaac-udy/Enro/tree/main'
                        }

                        if(isAndroid) {
                            withXml {
                                def dependenciesNode = asNode().getAt('dependencies')[0] ?: asNode().appendNode('dependencies')

                                // Iterate over the implementation dependencies (we don't want the test ones), adding a <dependency> node for each
                                configurations.implementation.allDependencies.each {
                                    // Ensure dependencies such as fileTree are not included.
                                    if (it.name != 'unspecified') {
                                        def dependencyNode = dependenciesNode.appendNode('dependency')
                                        dependencyNode.appendNode('groupId', it.group)
                                        dependencyNode.appendNode('artifactId', it.name)
                                        dependencyNode.appendNode('version', it.version)
                                    }
                                }
                            }
                        }
                    }
                }
            }

            repositories {
                maven {
                    name = "GitHubPackages"
                    url = uri("https://maven.pkg.github.com/isaac-udy/Enro")
                    credentials {
                        username = privateProperties['githubUser']
                        password = privateProperties['githubToken']
                    }
                }
            }

            repositories {
                maven {
                    // This is an arbitrary name, you may also use "mavencentral" or
                    // any other name that's descriptive for you
                    name = "sonatype"
                    url = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
                    credentials {
                        username privateProperties['sonatypeUser']
                        password privateProperties['sonatypePassword']
                    }
                }
            }
        }

        if (privateProperties['signingKeyId'] != "MISSING") {
            signing {
                sign publishing.publications
            }
        }
    }

    afterEvaluate {
        if(isAndroid) {
            tasks.findByName("publishToMavenLocal")
                    .dependsOn("assembleRelease")
        }
        else {
            tasks.findByName("publishToMavenLocal")
                    .dependsOn("assemble")
        }

        tasks.findByName("publish")
                .dependsOn("publishToMavenLocal")

        tasks.findByName("publishAllPublicationsToSonatypeRepository")
                .dependsOn("publishToMavenLocal")
    }
}