build.gradle

// For those who want the bleeding edge
buildscript {
    repositories {
        mavenCentral()
        jcenter()
        maven {
            name = "forge"
            url = "http://files.minecraftforge.net/maven"
        }
    }
    dependencies {
        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
        classpath 'com.github.jengelman.gradle.plugins:shadow:4.0.4'
    }
}

plugins {
    // For people who want stable
    //id "net.minecraftforge.gradle.forge" version "2.0.2"
    id 'com.matthewprenger.cursegradle' version '1.4.0'
	id 'com.github.kt3k.coveralls' version '2.8.2'
}

apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'idea'
apply plugin: 'maven'
apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: 'jacoco'

import net.minecraftforge.gradle.common.task.SignJar

loadProperties()

version = config.mod_version
group = "org.cyclops.integratedterminals"
archivesBaseName = "IntegratedTerminals"
sourceCompatibility = 1.8
targetCompatibility = 1.8

def loadProperties() {
    // Config file with custom properties
    ext.configFile = file "build.properties"
    configFile.withReader {
        def prop = new Properties()
        prop.load(it)
        ext.config = new ConfigSlurper().parse prop
    }

    // grab buildNumber
    ext.buildnumber = "DEV" // this will be referenced as simply project.buildnumber from now on.
    if (System.getenv().BUILD_NUMBER)
        project.buildnumber = System.getenv().BUILD_NUMBER
    if (System.getenv().TRAVIS_BUILD_NUMBER)
        project.buildnumber = System.getenv().TRAVIS_BUILD_NUMBER
    if (System.getenv().GITHUB_RUN_ID)
        project.buildnumber = System.getenv().GITHUB_RUN_NUMBER
    if (System.getenv().RELEASE || System.getenv().TRAVIS_TAG)
        project.buildnumber = "RELEASE"
    logger.lifecycle "BUILDING VERSION: " + project.buildnumber
}

sourceSets {
    main
    test
}

configurations {
    shadow.setTransitive(true);
}

test {
    testLogging {
        exceptionFormat = 'full'
    }
}

repositories {
    mavenCentral()
	mavenLocal()
    maven {
        name "Cyclops Repo"
        url "https://maven.pkg.github.com/CyclopsMC/packages"
        credentials {
            username = project.findProperty("gpr.user") ?: System.getenv("MAVEN_USERNAME")
            password = project.findProperty("gpr.key") ?: System.getenv("MAVEN_KEY")
        }
    }
}

dependencies {
    minecraft "net.minecraftforge:forge:${config.minecraft_version}-${config.forge_version}"

    // Add something like 'cyclopscore_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local CyclopsCore version.
    if(project.hasProperty("cyclopscore_version_local")) {
        compile "org.cyclops.cyclopscore:cyclopscore:${config.minecraft_version}-${project.cyclopscore_version_local}:deobf"
    } else {
        compile "org.cyclops.cyclopscore:cyclopscore:${config.minecraft_version}-${config.cyclopscore_version}:deobf"
    }
	
    // Add something like 'integrateddynamics_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local Integrated Tunnels Compat version.
    if(project.hasProperty("integrateddynamics_version_local")) {
        compile ("org.cyclops.integrateddynamics:integrateddynamics:${project.integrateddynamics_version_local}:deobf") {
            transitive = false
        }
    } else {
        compile ("org.cyclops.integrateddynamics:integrateddynamics:${config.integrateddynamics_version}:deobf") {
            transitive = false
        }
    }
	
    // Add something like 'integratedcrafting_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local Integrated Tunnels Compat version.
    if(project.hasProperty("integratedcrafting_version_local")) {
        compile "org.cyclops.integratedcrafting:integratedcrafting:${project.integratedcrafting_version_local}:deobf"
    } else {
        compile ("org.cyclops.integratedcrafting:integratedcrafting:${config.integratedcrafting_version}:deobf") {
            transitive = false
        }
    }

    // Add something like 'integratedterminalscompat_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local Integrated Tunnels Compat version.
    if(project.hasProperty("integratedterminalscompat_version_local")) {
        shadow("org.cyclops.integratedterminalscompat:integratedterminals-compat:${project.integratedterminalscompat_version_local}") {
            transitive = false
        }
    } else {
        shadow("org.cyclops.integratedterminalscompat:integratedterminals-compat:${config.integratedterminalscompat_version}") {
            transitive = false
        }
    }

    if(project.hasProperty("commoncapabilities_version_local")) {
        compile ("org.cyclops.commoncapabilities:commoncapabilities:${project.commoncapabilities_version_local}:deobf") {
            transitive = false
        }
    } else {
        compile ("org.cyclops.commoncapabilities:commoncapabilities:${config.commoncapabilities_version}:deobf") { // https://dl.bintray.com/cyclopsmc/dev/org/cyclops/commoncapabilities/CommonCapabilities/
            transitive = false
        }
    }
	
    runtime "com.google.re2j:re2j:1.1"

    // Project lombok
    compileOnly "org.projectlombok:lombok:1.16.4"
	
	testCompile "junit:junit:4.12"
}

minecraft {
    mappings channel: "${config.mcp_mappings_channel}", version: "${config.mcp_mappings_version}"

    runs {
        client {
            workingDirectory project.file('run')
            //property 'forge.logging.markers', 'REGISTRIES,REGISTRYDUMP'
            property 'forge.logging.console.level', 'debug'
            mods {
                integratedterminals {
                    source sourceSets.main
                }
            }
        }

        server {
            workingDirectory project.file('run')
            property 'forge.logging.console.level', 'debug'
            mods {
                integratedterminals {
                    source sourceSets.main
                }
            }
        }

        data {
            workingDirectory project.file('run')
            property 'forge.logging.console.level', 'debug'
            args '--mod', 'integratedterminals', '--all', '--output', file('src/generated/resources/')
            mods {
                integratedterminals {
                    source sourceSets.main
                }
            }
        }
    }
}

if (project.buildnumber.equals("RELEASE"))
    version = "${config.minecraft_version}-${config.mod_version}"
else
    version = "${config.minecraft_version}-${config.mod_version}-${buildnumber}"

jar {
    manifest {
        attributes([
                "Specification-Title": "${project.name}",
                "Specification-Vendor": "rubensworks",
                "Specification-Version": "${config.mod_version}",
                "Implementation-Title": "${project.name}",
                "Implementation-Version": "${config.mod_version}",
                "Implementation-Vendor" :"rubensworks",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}

task signJar(type: SignJar, dependsOn: jar) {
    onlyIf {
        System.getenv().SIGN_KEYSTORE
    }

    keyStore = System.getenv().SIGN_KEYSTORE
    alias = System.getenv().SIGN_ALIAS
    storePass = System.getenv().SIGN_STOREPASS
    keyPass = System.getenv().SIGN_KEYPASS
    inputFile = jar.archivePath
    outputFile = jar.archivePath
}
build.dependsOn signJar

task deobfJar(type: Jar) {
    from sourceSets.main.output
    classifier = 'deobf'
    manifest {
        attributes([
                "Specification-Title": "${project.name}",
                "Specification-Vendor": "rubensworks",
                "Specification-Version": "${config.mod_version}",
                "Implementation-Title": "${project.name}",
                "Implementation-Version": "${config.mod_version}",
                "Implementation-Vendor" :"rubensworks",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}

task sourceJar(type: Jar) {
    classifier = "sources"
    from sourceSets.main.allJava
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    from javadoc.destinationDir
    classifier 'javadoc'
}

shadowJar {
    configurations = [project.configurations.shadow]
    classifier '' // Replace the default JAR
    append 'META-INF/mods.toml'
    relocate 'com.google.re2j', 'vendors.com.google.re2j' // Because Forge blocks all com.google.* class loading...
}

reobf {
    shadowJar {} // Reobfuscate the shadowed JAR
}

artifacts {
    archives deobfJar
    archives sourceJar
    archives javadocJar
}

curseforge {
    if(project.hasProperty("curseforge_key")) {
        apiKey = project.curseforge_key
    } else if((System.getenv().TRAVIS || System.getenv().GITHUB_ACTIONS) && System.getenv().CURSEFORGE_KEY_SECRET) {
        apiKey = System.getenv().CURSEFORGE_KEY_SECRET
    }

    project {
        id = "295910" // my project url is http://minecraft.curseforge.com/mc-mods/295910/
        releaseType = project.config.release_type
        mainArtifact(jar) {
            relations {
                requiredDependency 'cyclops-core'
                requiredDependency 'integrated-dynamics'
                requiredDependency 'integrated-tunnels'
                optionalDependency 'integrated-crafting'
            }
        }

        changelog = ""
        if (new File("resources/changelog/${project.version}.txt").exists()) {
            changelog = new File("resources/changelog/${project.version}.txt").text
        }

        addArtifact deobfJar
        addArtifact sourceJar
        addArtifact javadocJar
    }
}

configurations {
    deployerJars
}

dependencies {
    deployerJars "org.apache.maven.wagon:wagon-ftp:2.2"
}

uploadArchives {
    repositories {
        add getProject().repositories.mavenLocal()
    }
    repositories.mavenDeployer {
        configuration = configurations.deployerJars

        if (project.hasProperty("filesmaven_url")) {
            logger.info('Publishing to files server')
            repository(url: project.filesmaven_url) {
                authentication(userName: project.filesmaven_username, password: project.filesmaven_key)
            }
        } else if (System.getenv().MAVEN_URL) {
            logger.info('Publishing to files server')
            repository(url: System.getenv().MAVEN_URL) {
                authentication(userName: System.getenv().MAVEN_USERNAME, password: System.getenv().MAVEN_KEY)
            }
        } else {
            logger.info('Publishing to repo folder')
            repository(url: 'file://localhost/' + project.file('~/.m2/repository').getAbsolutePath())
        }

        pom {
            groupId = project.group
            version = project.version
            artifactId = project.archivesBaseName.toLowerCase()
        }
        pom.project {
            name project.archivesBaseName
            packaging 'jar'
            description 'todo'
            url 'https://github.com/CyclopsMC/IntegratedTerminals'

            scm {
                url 'https://github.com/CyclopsMC/IntegratedTerminals'
                connection 'scm:git:git://github.com/CyclopsMC/IntegratedTerminals.git'
                developerConnection 'scm:git:git@github.com:CyclopsMC/IntegratedTerminals.git'
            }

            issueManagement {
                system 'github'
                url 'https://github.com/CyclopsMC/IntegratedTerminals/issues'
            }

            developers {
                developer {
                    id 'rubensworks'
                    name 'rubensworks'
                    roles { role 'developer' }
                }
            }
        }
    }
}
uploadArchives.dependsOn build

idea {
    module {
        for (String excludeDirName in ["run", "out", "logs", "gradle"]) {
            File excludeDir = new File(projectDir, excludeDirName)
            excludeDirs.add(excludeDir)
        }
    }
}

jacocoTestReport {
    reports {
        xml.enabled = true
        html.enabled = true
    }
}