build.gradle

//use: gradlew clean build fatJar signArchives install bintrayUpload
import org.apache.tools.ant.filters.ReplaceTokens

plugins {
    id "com.jfrog.bintray" version "1.6"
}

apply plugin: 'java'
apply plugin: 'maven'
apply plugin: 'signing'
apply plugin: 'eclipse'

def versionObj = new Version(major: 0, minor: 2, revision: 1)
group = "net.dv8tion"
archivesBaseName = "jda-player"
version = "$versionObj"

sourceCompatibility = 1.8
targetCompatibility = 1.8

tasks.eclipse.dependsOn(cleanEclipse)

def filteredSourceDir = file("$buildDir/filtered")

// This is to fix eclipse's stupidity when first setting up the project.
// It thinks that "filtered" should be a development source folder and cries when it doesn't exist (gradlew clean)
eclipse {
    classpath {
        file {
            withXml {
                def sb = it.asString()
                sb.replace(0, sb.length(), sb.toString().replace("\n\t<classpathentry kind=\"src\" path=\"build/filtered\"/>", ""));
            }
        }
    }
}


sourceSets {
    // This source set will contain all sources that we filter
    filtered {
        java {
            srcDirs = [
                    filteredSourceDir,
                    "src/test/java",
            ]
        }
    }
}

javadoc {
    failOnError = false
}

// copy the main sources and filter any '@buildVersion@' occurences.
task processVersion (type: Copy) {
    from sourceSets.main.java
    into filteredSourceDir
    filter(ReplaceTokens, tokens: [
            versionMajor: versionObj.major.toString(),
            versionMinor: versionObj.minor.toString(),
            versionRevision: versionObj.revision.toString(),
            versionBuild: versionObj.build.toString()
    ])
}

jar {
    baseName = project.name
    manifest {
        attributes 'Implementation-Version': version
    }
    include "net/dv8tion/jda/**"
}

task javadocJar(type: Jar) {
    classifier = 'javadoc'
    from javadoc
}

task sourcesJar(type: Jar) {
    classifier = 'sources'
    from sourceSets.filtered.java
    include "net/dv8tion/jda/**"
}

// create a single Jar with all dependencies
task fatJar(type: Jar) {
    manifest {
        attributes 'Implementation-Version': version
    }

    baseName = project.name + '-withDependencies'
    from {
        configurations.compile.collect {
            dependency ->
                if (dependency.directory) { // If it is a folder, just include the folder in its entirety
                    return dependency
                } else {    // If it isn't a folder, put it in a zipTree. if it is a zip or jar the contents will be extracted.
                    return zipTree(dependency)
                }
        }
    }
    with jar
}

artifacts {
    archives javadocJar, sourcesJar
}

signing {
    sign configurations.archives
}
repositories {
    jcenter()
}

dependencies {
    compile 'net.dv8tion:JDA:2.0.0_251'
}

class Version {
    int major, minor, revision

    String getBuild() {
        System.getenv("BUILD_NUMBER") ?: System.getProperty("BUILD_NUMBER") ?: "DEV"
    }

    String toString() {
        "${major}.${minor}.${revision}_$build"
    }
}

bintray {

    user = bintrayUsername
    key = bintrayApiKey
    pkg {
        repo = 'maven'
        name = 'JDA-Player'
        licenses = ['Apache-2.0']
        vcsUrl = 'https://github.com/DV8FromTheWorld/JDA-Player.git'
        filesSpec {
            from ('build/libs') {
                exclude "**withDependencies**"
            }
            from 'build/poms'
            into "${project.group.replace(".", "/")}/${archivesBaseName}/${project.version}"

            rename { String fileName ->
                fileName.replace("pom-default.xml", "${archivesBaseName}-${project.version}.pom")
            }
        }
        publish = true
        version {
            name = project.version
            released = new Date()
        }
    }
}

bintrayUpload {
    onlyIf {
        System.getenv("BUILD_NUMBER")
    }
}

String getProjectProperty(String propertyName)
{
    String property = ""
    if (hasProperty(propertyName))
    {
        property = this.properties[propertyName]
    }
    return property
}

// tell the compileJava task to compile the filtered source
compileJava.source = sourceSets.filtered.java
compileJava.dependsOn processVersion

//use: gradlew clean build fatJar signArchives install bintrayUpload

// If we don't have the username and password for uploading, we probably also
// can't sign the archives, so skip these tasks.
signArchives.onlyIf {(!getProjectProperty("signing.keyId").empty
    && !getProjectProperty("signing.password").empty
    && !getProjectProperty("signing.secretKeyRingFile").empty) }
bintrayUpload.onlyIf { (!getProjectProperty("bintrayUsername").empty
        && !getProjectProperty("bintrayApiKey").empty) }