build.gradle

plugins {
    id 'fabric-loom' version '0.2.5-SNAPSHOT'
    id 'maven-publish'
    id 'com.jfrog.bintray' version '1.8.4'
    id 'net.minecrell.licenser' version '0.4.1'
}

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

if (isNullOrEmpty(System.getenv("TRAVIS_TAG")) && !isNullOrEmpty(System.getenv('TRAVIS_BUILD_NUMBER'))) {
    version = project.modVersion + '.' + System.getenv('TRAVIS_BUILD_NUMBER')
} else {
    version = project.modVersion
}
logger.lifecycle("${project.repoName} version ${project.version}")
group = project.mavenGroup

minecraft {
}

dependencies {
    //to change the versions see the gradle.properties file
    minecraft "com.mojang:minecraft:${project.minecraftVersion}"
    mappings "net.fabricmc:yarn:${project.yarnMappings}"
    modCompile "net.fabricmc:fabric-loader:${project.loaderVersion}"

    compileOnly "org.checkerframework:checker-qual:2.11.0"

    // Fabric API. This is technically optional, but you probably want it anyway.
    modCompile "net.fabricmc.fabric-api:fabric-api:${project.apiVersion}"

    // PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs.
    // You may need to force-disable transitiveness on them.

    annotationProcessor 'net.fabricmc:fabric-mixin-compile-extensions:0.1.0.+'
}

sourceSets {
    code {
        compileClasspath += sourceSets.main.compileClasspath
        compileClasspath += configurations.minecraftNamed
        runtimeClasspath += sourceSets.main.runtimeClasspath
        compileClasspath += configurations.minecraftNamed
    }
    data {
        compileClasspath += sourceSets.code.compileClasspath
        compileClasspath += sourceSets.code.output
        runtimeClasspath += sourceSets.code.compileClasspath
        runtimeClasspath += sourceSets.code.output
    }
    main {
        compileClasspath += sourceSets.code.compileClasspath
        compileClasspath += sourceSets.code.output
        runtimeClasspath += sourceSets.code.compileClasspath
        runtimeClasspath += sourceSets.code.output
    }
}

license {
    header = file('HEADER.txt')
    include '**/*.java'
    style.java = 'BLOCK_COMMENT'
    newLine = false
}

// ensure that the encoding is set to UTF-8, no matter what the system default is
// this fixes some edge cases with special characters not displaying correctly
// see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
tasks.withType(JavaCompile) {
    options.encoding = "UTF-8"
    // Loom is just so cursed that it does not handle extra source sets nicely
    options.annotationProcessorPath += configurations.annotationProcessor
    doFirst {
        def args = options.compilerArgs
        project.minecraft {
            args.add "-AinMapFileNamedIntermediary=" + mappingsProvider.MAPPINGS_TINY.canonicalPath
            args.add "-AoutMapFileNamedIntermediary=" + mappingsProvider.MAPPINGS_MIXIN_EXPORT.canonicalPath
            args.add "-AoutRefMapFile=" + new File(destinationDir, refmapName).canonicalPath
            args.add "-AdefaultObfuscationEnv=named:intermediary"
        }
    }
}

tasks.withType(Javadoc) {
    options.encoding = 'UTF-8'
    options.charSet = 'UTF-8'
    options.links(
            'https://google.github.io/guava/releases/21.0/api/docs/',
            'http://asm.ow2.org/asm50/javadoc/user/',
            'https://docs.oracle.com/javase/8/docs/api/',
            'http://jenkins.liteloader.com/job/Mixin/javadoc/',
            'https://logging.apache.org/log4j/2.x/log4j-api/apidocs/'
            // Need to add minecraft jd publication once there is one available
    )

    // Disable the crazy super-strict doclint tool in Java 8
    options.addStringOption('Xdoclint:none', '-quiet')
}

def dataDir = file("$buildDir/datadump/")
def dataCacheDir = file("$dataDir/.cache/")
def outputDirectory = file("$buildDir/pom-properties")
def pomProperties = file("$outputDirectory/pom.properties")

task generatePomPropertiesForJar {
    outputDirectory.mkdirs()
    pomProperties.text = """# Generated by Gradle ${gradle.gradleVersion} on ${new Date()}
groupId=${project.group}
artifactId=${project.name}
version=${project.version}
"""
    outputs.file(pomProperties)
}

task generateData(type: JavaExec) {
    doFirst {
        dataDir.mkdirs()
    }

    classpath = sourceSets.data.runtimeClasspath

    main = project.dataEntry

    // arguments to pass to the application

    workingDir dataDir
    inputs.files sourceSets.data.output
    outputs.dir dataDir
    args dataDir.getAbsolutePath()

    doLast {
        dataCacheDir.delete()
    }
}

processResources {
    from(generateData.outputs.files) {
        include "/data/"
    }
    from sourceSets.code.resources.srcDirs

    inputs.properties "version": project.version, "description": project.description

    from(sourceSets.main.resources.srcDirs) {
        include "fabric.mod.json"
        include "pack.mcmeta"
        expand(
                "version": project.version,
                "description": project.description,
                "repoOwner": project.repoOwner,
                "repoName": project.repoName,
                "id": project.modId,
                "minecraftVersionLimit": project.minecraftVersionLimit,
                "loaderVersionLimit": project.loaderVersionLimit
        )
    }

    from(sourceSets.main.resources.srcDirs) {
        exclude "fabric.mod.json"
        exclude "pack.mcmeta"
    }
}

// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
// if it is present.
// If you remove this task, sources will not be generated.
task sourcesJar(type: Jar, dependsOn: classes) {
    archiveClassifier.set "sources"
    from sourceSets.code.allSource
}

task javadocs(type: Javadoc) {
    source = sourceSets.code.allJava
}

task javadocsJar(type: Jar, dependsOn: javadocs) {
    archiveClassifier.set "javadocs"
    from javadocs.destinationDir
}

jar {
    dependsOn generateData
    from sourceSets.code.output
    from "LICENSE"
}

artifacts {
    archives jar
    archives sourcesJar
    archives javadocsJar
}

bintray {
    user = project.hasProperty('bintrayUser') ? project.getProperty('bintrayUser') : System.getenv('bintray_user')
    key = project.hasProperty('bintrayKey') ? project.getProperty('bintrayKey') : System.getenv('bintray_key')
    publish = true
    override = true
    publications = ['mavenJava']
    pkg {
        repo = project.bintrayRepo
        name = project.name
        user = bintray.user
        userOrg = project.repoOwner
        licenses = [project.codeLicense]
        desc = project.description
        websiteUrl = "https://github.com/${project.repoOwner}/${project.repoName}"
        issueTrackerUrl = "https://github.com/${project.repoOwner}/${project.repoName}/issues"
        vcsUrl = "https://github.com/${project.repoOwner}/${project.repoName}.git"
        publicDownloadNumbers = true

        githubRepo = "${project.repoOwner}/${project.repoName}"
        version {
            name = project.version
            released = new Date()
            if (!isNullOrEmpty(System.getenv("TRAVIS_TAG"))) {
                vcsTag = System.getenv("TRAVIS_TAG")
            } else {
                vcsTag = ''
            }
        }
    }
}

// configure the maven publication
publishing {
    publications {
        mavenJava(MavenPublication) {
            pom {
                name = project.name
                description = project.description
                url = "https://github.com/${project.repoOwner}/${project.repoName}"
                licenses {
                    license {
                        name = project.codeLicense
                    }
                }

                scm {
                    url = "https://github.com/${project.repoOwner}/${project.repoName}"
                }
            }

            // add all the jars that should be included when publishing to maven
            artifact(jar) {
                classifier = null
                builtBy remapJar
            }
            artifact(sourcesJar) {
                classifier = "sources"
                builtBy remapSourcesJar
            }
            artifact javadocsJar
        }
    }

    if (!isNullOrEmpty(System.getenv('GITHUB_OAUTH_TOKEN'))) {
        publications {
            mavenGitHub(MavenPublication) {
                pom {
                    name = project.name
                    description = project.description
                    url = "https://github.com/${project.repoOwner}/${project.repoName}"
                    licenses {
                        license {
                            name = project.codeLicense
                        }
                    }

                    scm {
                        url = "https://github.com/${project.repoOwner}/${project.repoName}"
                    }
                }

                // add all the jars that should be included when publishing to maven
                artifact(jar) {
                    classifier = null
                    builtBy remapJar
                }
            }
        }
        // select the repositories you want to publish to
        repositories {
            maven {
                name = "GitHub"
                url = uri("https://maven.pkg.github.com/${project.repoOwner}/${project.repoName}")
                credentials {
                    username = "${project.githubPackagePublisher}"
                    password = System.getenv('GITHUB_OAUTH_TOKEN')
                }
            }
        }
    }
}

tasks.withType(Jar) {
    dependsOn("generatePomFileForMavenJavaPublication", "generatePomPropertiesForJar")
    into("META-INF/maven/${project.group}/${project.name}") {
        from(generatePomFileForMavenJavaPublication) {
            rename(".+", "pom.xml")
        }
        from(generatePomPropertiesForJar)
    }
}

static boolean isNullOrEmpty(String st) {
    return st == null || st.isEmpty()
}