build.gradle

/*
 * Copyright 2016-2021 John Grosh (jagrosh) & Kaidan Gustave (TheMonitorLizard)
 *
 * 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.
 */
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.apache.tools.ant.filters.ReplaceTokens

plugins {
    id 'maven-publish'
    id "com.github.ben-manes.versions" version "0.39.0"
    id "com.github.johnrengelman.shadow" version "7.0.0"
}

def versionInfo = [major: '2', minor: System.getenv("BUILD_NUMBER") ?: "0-SNAPSHOT"]

task build {
    group = 'build'
}

allprojects {
    apply plugin: 'maven-publish'
    apply plugin: 'com.github.johnrengelman.shadow'

    group = 'pw.chew'
    version = versionInfo.values().join('.')

    ext {
        jdaVersion = '5.0.0-beta.7'
        slf4jVersion = '1.7.36'
        okhttpVersion = '4.9.3'
        findbugsVersion = '3.0.2'
        jsonVersion = '20220320'
        junitVersion = '4.13.1' // TODO Move to junit 5?

        dependencies {
            jda = { [group: 'net.dv8tion', name: 'JDA', version: jdaVersion] }
            slf4j = { [group: 'org.slf4j', name: 'slf4j-api', version: slf4jVersion] }
            okhttp = { [group: 'com.squareup.okhttp3', name: 'okhttp', version: okhttpVersion] }
            findbugs = { [group: 'com.google.code.findbugs', name: 'jsr305', version: findbugsVersion] }
            json = { [group: 'org.json', name: 'json', version: jsonVersion] }
            junit = { [group: 'junit', name: 'junit', version: junitVersion] }

            artifactId = (rootProject == project? project.name : "$rootProject.name-$project.name").toLowerCase(Locale.ROOT)
            moduleName = "${group}.jdautilities${rootProject == project? "" : ".${project.name.toLowerCase(Locale.ROOT)}"}"
        }

        // Helper task that allows us to do a one-line method call to fully
        //configure a jar task. This prevents possible build inconsistencies.
        configureJar = { Object jarConfig, String classifier = '' ->
            jarConfig.baseName = "$project.artifactId"
            jarConfig.version = "$project.version"
            jarConfig.classifier = classifier
            jarConfig.extension = 'jar'

            jarConfig.manifest {
                it.attributes(
                        'Implementation-Title': project.artifactId,
                        'Implementation-Version': project.version,
                        'Automatic-Module-Name': "${project.moduleName}"
                )
            }
        }

        // Similar to the extension above, helps keep javadoc
        //characteristics consistent between artifacts.
        configureJavadoc = { Object jDocConfig ->
            jDocConfig.options {
                it.author()
                it.encoding = 'UTF-8'
                it.memberLevel = JavadocMemberLevel.PROTECTED
                it.tags 'apiNote:a:API Note:', 'implSpec:a:Implementation Requirements:', 'implNote:a:Implementation Note:'
            }
        }
    }

    // Create dependency shortcut for every subproject
    rootProject.subprojects.forEach { subproject ->
        project.ext."$subproject.name" = { project(":$subproject.name") }
    }

    repositories {
        mavenCentral()
    }

    build {
        // These have to be run in closures
        //because they are defined later in the buildscript.
        // Trying to specify these at "script-refresh" time
        //will cause the refresh to fail.
        dependsOn { javadocJar }
        dependsOn { sourceJar }
        dependsOn { shadowJar }
    }

    publishing {
        publications {
            maven(MavenPublication) {
                groupId = project.group
                artifactId = project.artifactId
                version = project.version
            }
        }
        repositories {
            maven {
                def releasesRepoUrl = "https://m2.chew.pro/releases"
                def snapshotsRepoUrl = "https://m2.chew.pro/snapshots"
                url = project.version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
                credentials {
                    username = project.property("mchew-username")
                    password = project.property("mchew-password")
                }
            }
        }
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'com.github.ben-manes.versions'

    ext {
        // Allow for individual modules to be marked as excluded
        //from the collective artifact (IE: jda-utilities)
        includeInParent = true
    }

    sourceSets {
        // add main classpath to test classpath
        test {
            java.srcDirs += 'src/test/java'
            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath
        }
    }

    task sourcesForRelease(type: Copy) {
        from('src/main/java') {
            filter(ReplaceTokens, tokens: [
                VERSION_MAJOR:    versionInfo.major,
                VERSION_MINOR:    versionInfo.minor
            ])
        }
        into 'build/filteredSrc'
    }

    compileJava {
        source = sourcesForRelease.destinationDir
        classpath = sourceSets.main.compileClasspath

        dependsOn sourcesForRelease
    }

    javadoc {
        destinationDir = file("$buildDir/docs/")

        configureJavadoc(it)
    }

    jar {
        configureJar(it)
    }

    shadowJar {
        configureJar(it, 'all')
    }

    task javadocJar(type: Jar) {
        group = 'build'
        dependsOn javadoc
        from javadoc.destinationDir
        configureJar(it, 'javadoc')
    }

    task sourceJar(type: Jar) {
        group = 'build'
        dependsOn classes
        from sourceSets.main.allSource
        configureJar(it, 'sources')
    }

    publishing {
        publications {
            maven(MavenPublication) {
                from components.java
                artifact javadocJar
                artifact sourceJar
            }
        }
    }

    afterEvaluate {
        if(project.includeInParent) {
            rootProject.dependencies.implementation project
        }
    }
}

configurations {
    implementation {
        description = 'implementation'
        transitive = true
    }
}

task javadoc(type: Javadoc) {
    group = 'documentation'
    dependsOn { subprojects*.getTasksByName('javadoc', true) }

    source = { subprojects*.sourceSets.main.allJava }
    classpath = files(subprojects*.javadoc.classpath)

    destinationDir = file("$buildDir/docs/")

    configureJavadoc(it)
}

// Jar tasks

task jar(type: ShadowJar) {
    group = 'build'

    configureJar(it)

    from { subprojects*.jar }
    destinationDir = file("$buildDir/libs/")
}

task shadowJar(type: ShadowJar) {
    group = 'shadow'
    dependsOn { rootProject.getTasksByName('jar', true) }

    it.configurations += configurations.runtime
    configureJar(it, 'all')

    from { subprojects*.jar }
    destinationDir = file("$buildDir/libs/")
}

task javadocJar(type: Jar) {
    group = 'build'
    dependsOn { tasks.javadoc }

    configureJar(it, 'javadoc')

    from { javadoc.destinationDir }
    destinationDir = file("$buildDir/libs/")
}

task sourceJar(type: Jar) {
    group = 'build'
    dependsOn { rootProject.getTasksByName('classes', true) }

    configureJar(it, 'sources')

    from { subprojects*.sourceSets.main.allSource }
    destinationDir = file("$buildDir/libs/")
}

task clean(type: Delete) {
    group = 'build'

    delete = buildDir
}

publishing {
    publications {
        maven(MavenPublication) {
            pom.withXml {
                def repositoriesNode = asNode().appendNode('repositories')
                def repositoryNode = repositoriesNode.appendNode('repository')

                repositoryNode.appendNode('name', 'm2-chew')
                repositoryNode.appendNode('id', 'm2-chew')
                repositoryNode.appendNode('url', 'https://m2.chew.pro')

                def dependenciesNode = asNode().appendNode('dependencies')
                configurations.implementation.allDependencies.each {
                    def dependencyNode = dependenciesNode.appendNode('dependency')
                    dependencyNode.appendNode('groupId', it.group)
                    dependencyNode.appendNode('artifactId', it instanceof ProjectDependency ? it.dependencyProject.artifactId : it.name)
                    dependencyNode.appendNode('version', it.version)
                    dependencyNode.appendNode('scope', 'compile')
                }
            }
        }
    }
}