build.gradle

/*
 * OpenPeripheralCore build file.
 * @author Arkan <arkan@emberwalker.cc>
 */

//================================================
// Pre-execute

buildscript {
    repositories {
        // General deps
        mavenCentral()
        // Minecraft Forge
        maven {
            name = 'Forge'
            url = 'http://files.minecraftforge.net/maven'
        }
        // Sonatype (for SpecialSource in 1.7+)
        maven {
            name = "Sonatype Nexus"
            url = "https://oss.sonatype.org/content/repositories/snapshots/"
        }
        maven {
              name 'OpenMods Third Party'
              url 'http://repo.openmods.info/artifactory/simple/thirdparty'
        }
    }

    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
        classpath 'net.thesilkminer.gradle.translationchecker:TranslationChecker:1.1'
    }
}

apply plugin: 'forge'
apply plugin: 'java'
apply plugin: "maven"

repositories {
    maven {
        name = "OC repo"
        url = "http://maven.cil.li/"
    }
}

configurations {
    apiReleaseCompile
    compile.extendsFrom apiReleaseCompile
}

dependencies {
    compile project(":OpenModsLib")

    // apiCompile "info.computercraft:ComputerCraft-API:???"
    apiReleaseCompile "li.cil.oc:OpenComputers:MC1.7.10-1.5.0.5:api"

    testCompile group: 'junit', name: 'junit', version: '4.12'
    testCompile "org.mockito:mockito-core:1.10.19"
}

//================================================
// Jar data

// Grab system env
ext.env = System.getenv()

version = mc_ver + "-" + mod_version

ext.in_jenkins = false
// Get Jenkins metadata
ext.jenkinsManifest = manifest {
    if (env.BUILD_TAG != null) { // If this works, we'll assume we're in Jenkins atleast.
        attributes("Jenkins-Build": "true", "Jenkins-Tag": env.BUILD_TAG, "Jenkins-ID": env.BUILD_ID)
        in_jenkins = true
    } else {
        attributes("Jenkins-Build": "false")
    }
}

def branch = null
def hash = null
def proc1 = "git rev-parse --short HEAD".execute()
proc1.in.eachLine { line -> hash = line }
proc1.err.eachLine { line -> println line }
proc1.waitFor()

if (!in_jenkins) {
    def proc2 = "git rev-parse --abbrev-ref HEAD".execute()
    proc2.in.eachLine { line -> branch = line }
    proc2.err.eachLine { line -> println line }
    proc2.waitFor()
} else { // In Jenkins
    branch = env.GIT_BRANCH.minus("origin/")
}

// If not on master, add branch to jar name
if (branch != null && !branch.equals("master")) {
    version += "-" + branch
} else {
    //version += "-" + hash
}

// Version tag for jar file name
if (env.BUILD_NUMBER != null) {
    version += "-snapshot-" + env.BUILD_NUMBER
}

// Get Git metadata (if in Jenkins)
ext.gitManifest = manifest {
    if (env.GIT_BRANCH != null) {
        attributes("Git-Branch": branch, "Git-Hash": hash)
    }
}

// Setup Forge plugin
minecraft {
    version = mc_ver + "-" + forge_ver
    runDir = 'eclipse/assets'

    replaceIn "openperipheral/ModInfo.java"
    replaceIn "openperipheral/api/ApiAccess.java"
    replace '$VERSION$', mod_version
    replace '$OP-API-VERSION$', api_version
    replace '$LIB-VERSION$', project(':OpenModsLib').mod_version
    replace '$NEXT-LIB-VERSION$', project(':OpenModsLib').next_mod_version
}

processResources {
    inputs.property "version", rootProject.mod_version

    // Process mcmod.info
    from(sourceSets.main.resources.srcDirs) {
        include '**/*.info'
        expand 'version':mod_version,'MCVersion':mc_ver
    }

    // Copy anything else directly
    from(sourceSets.main.resources.srcDirs) {
        exclude '**/*.info'
    }
}

javadoc {
    include 'openperipheral/api/**'

    if (JavaVersion.current().isJava8Compatible()) {
        options.addBooleanOption('Xdoclint:accessibility,html,syntax', true)
    }
}

//================================================
// Jar tasks

// Generate FML Coremod manifest
ext.fmlManifest = manifest {}

// Merge Jenkins and Git manifests to form final manifest in final release jar
jar {
    manifest {
        from jenkinsManifest, gitManifest, fmlManifest
    }
}

// Dev jar
task deobfJar(type: Jar) {
    classifier 'deobf'

    from sourceSets.main.output

    manifest {
        from jenkinsManifest, gitManifest, fmlManifest
    }
}

ext.sourcesPath = new File(new File(buildDir, "sources"), "java")

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier 'sources'

    from sourcesPath

    manifest {
        from jenkinsManifest, gitManifest
    }
}

def API_NAME = "OpenPeripheralCore-API"

task apiJar(type: Jar) {
    baseName API_NAME
    version api_version

    from sourceSets.main.output
    from sourcesPath

    include 'openperipheral/api/**'

    manifest {
        from jenkinsManifest, gitManifest
    }
}

task apiSrcJar(type: Jar) {
    baseName API_NAME
    version api_version
    classifier 'sources'

    from sourcesPath

    include 'openperipheral/api/**'

    manifest {
        from jenkinsManifest, gitManifest
    }
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    baseName API_NAME
    version api_version
    classifier 'javadoc'

    from 'build/docs/javadoc'

    manifest {
        from jenkinsManifest, gitManifest
    }
}

artifacts {
    archives deobfJar
    archives sourcesJar
    archives apiJar
    archives apiSrcJar
    archives javadocJar
}

task updateTranslations(type: net.thesilkminer.gradle.plugin.translationchecker.tasks.TranslationCheckTask) {
    modId = "openperipheracore"
}

task checkTranslations(type: net.thesilkminer.gradle.plugin.translationchecker.tasks.TranslationCheckTask) {
    modId = "openperipheracore"
    dryRun = true
}

task wrapper (type: Wrapper) {
    gradleVersion = "2.12"
}

uploadArchives {
    repositories.mavenDeployer {

        dependsOn 'build'
        repository(url: 'file://localhost/' + project.file('repo').getAbsolutePath())

        addFilter('api') {artifact, file ->
                artifact.name == API_NAME
        }

        pom('api') {
            groupId = "info.openmods"
            version = api_version
            artifactId = API_NAME

            scopeMappings.mappings.clear()
            scopeMappings.addMapping(0, configurations.apiReleaseCompile, Conf2ScopeMappingContainer.COMPILE)

            project {
                name API_NAME
                packaging 'jar'
                description 'OpenPeripheralCore API'
                url 'https://github.com/OpenMods/OpenPeripheral'

                scm {
                    url 'https://github.com/OpenMods/OpenPeripheral'
                    connection 'scm:git:git@github.com:OpenMods/OpenPeripheral.git'
                    developerConnection 'scm:git:git@github.com:OpenMods/OpenPeripheral.git'
                }

                issueManagement {
                    system 'github'
                    url 'https://github.com/OpenMods/OpenPeripheral/issues'
                }

                licenses {
                    license {
                        name 'MIT'
                        url 'https://github.com/OpenMods/OpenPeripheral/blob/master/LICENSE'
                        distribution 'repo'
                    }
                }

                developers {
                    developer {
                        id 'boq'
                        name 'boq'
                        roles { role 'developer' }
                    }
                    developer {
                        id 'mikemoo'
                        name 'Mikemoo'
                        roles { role 'developer' }
                    }
                    developer {
                        id 'sinz'
                        name 'SinZ'
                        roles { role 'developer' }
                    }
                    developer {
                        id 'theoriginalbit'
                        name 'theoriginalbit'
                        roles { role 'developer' }
                    }
                }
            }
        }
    }
}