build.gradle

// Credits to UpcraftLP for the base build script


import java.time.Year

plugins {
    id "fabric-loom" version "0.4-SNAPSHOT"
    id "com.github.fudge.forgedflowerloom" version "2.0.0"
    id 'net.minecrell.licenser' version '0.4.1'
    id 'com.matthewprenger.cursegradle' version '1.4.0'
    id "com.jfrog.bintray" version '1.8.4'
    id 'org.ajoberstar.grgit' version '3.1.1'
    id 'com.github.breadmoirai.github-release' version '2.2.9'
    id "com.wynprice.cursemaven" version "2.1.5"
    id 'maven-publish'
}

group = rootProject.maven_group
archivesBaseName = rootProject.name
version = mod_version

subprojects {
    apply plugin: 'fabric-loom'
    apply plugin: 'com.matthewprenger.cursegradle'
    apply plugin: 'maven-publish'
}

allprojects {

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    version = rootProject.mod_version

    // Adds a few utility methods like getProjectProperty
    apply from: 'https://raw.githubusercontent.com/NerdHubMC/Gradle-Scripts/master/scripts/utilities.gradle'

    repositories {
        mavenLocal()
        mavenCentral()
    }

    // 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'
    }

    jar {
        from(sourceSets.main.output) {
            include 'fabric.mod.json'
            expand 'version': project.version
        }
        from(sourceSets.main.output) {
            exclude 'fabric.mod.json'
        }
    }

    task sourcesJar(type: Jar, dependsOn: classes) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

    apply from: 'https://raw.githubusercontent.com/OnyxStudios/Gradle-Scripts/master/scripts/fabric/publish/changelog.gradle'

    dependencies {
        //to change the versions see the gradle.properties file
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
        modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

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

        compileOnly "com.google.code.findbugs:jsr305:3.0.2"
        compileOnly "org.jetbrains:annotations:${jb_annotations_version}"
        compileOnly "org.apiguardian:apiguardian-api:${apiguardian_version}"
        compileOnly "com.demonwav.mcdev:annotations:1.0"

        testImplementation "org.junit.jupiter:junit-jupiter-api:5.4.0-M1"
    }

    license {
        header = rootProject.file("code_quality/${project.license_header}_HEADER.txt")

        matching('ladysnake/**/api/**') {
            header = rootProject.file("code_quality/${project.api_license_header}_HEADER.txt")
        }

        include '**/*.java'
        exclude '**/package-info.java'

        //export variables
        ext {
            year = Year.now()
            projectDisplayName = rootProject.display_name
            projectOwners = rootProject.owners
            gplVersion = rootProject.gpl_version
        }

        newLine = false // Disables the empty line between the header and package name
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifact(remapJar)
                artifact(sourcesJar) {
                    builtBy(remapSourcesJar)
                }

                if (project.tasks.findByName('javadocJar')) {
                    artifact project.tasks.getByName('javadocJar')
                }
            }
        }
    }
}

repositories {
    jcenter()
    maven {
        name = 'Ladysnake Libs'
        url = 'https://dl.bintray.com/ladysnake/libs'
    }
    maven {
        name = 'CottonMC'
        url = 'http://server.bbkr.space:8081/artifactory/libs-release'
    }
    maven {
        url "https://maven.jamieswhiteshirt.com/libs-release/"
    }
    maven {
        name = 'JitPack'
        url = 'https://jitpack.io'
    }
    mavenLocal()
}

dependencies {
    compile project(":requiem-api")
    // including too early causes a circular dependency somehow
    afterEvaluate {
        include project(":requiem-api")
    }

    modApi("io.github.ladysnake:Satin:${rootProject.satin_version}")
    include "io.github.ladysnake:Satin:${satin_version}"
    modRuntime ("io.github.prospector:modmenu:${modmenu_version}") {
        transitive = false
    }
    include "io.github.onyxstudios.Cardinal-Components-API:cardinal-components-base:${cca_version}"
    modImplementation ("io.github.onyxstudios.Cardinal-Components-API:cardinal-components-entity:${cca_version}")
    include "io.github.onyxstudios.Cardinal-Components-API:cardinal-components-entity:${cca_version}"
    modImplementation ("io.github.ladysnake:PlayerAbilityLib:${pal_version}")
    include "io.github.ladysnake:PlayerAbilityLib:${pal_version}"

//    modRuntime curse.resolve('immersive-portals-mod', 2845123)
//    modRuntime "curse.maven:mobz:2965825"
    modCompileOnly("io.github.Terrails:Health-Overlay:1.16-Fabric-SNAPSHOT")

    modRuntime "com.jamieswhiteshirt:reach-entity-attributes:1.0.1"
    modCompileOnly("io.github.apace100:origins-fabric:v0.3.6") {
        transitive = false
    }
    modRuntime("io.github.apace100:origins-fabric:v0.3.6") {
        transitive = false
    }
}

remapJar.dependsOn(project(":requiem-api").tasks.remapJar)

jar {
    from 'LICENSE-CODE'
    from 'LICENSE-ART'
}

license {
    exclude '**/RayHelper.java'
}

task checkGitStatus() {
    group = 'publishing'
    description = 'Checks that the git repository is in a state suitable for release'
    doLast {
        if (grgit == null) throw new RuntimeException('No git repository')
        if (!grgit.status().isClean()) {
            throw new RuntimeException("Git repository not ready for release (${grgit.status()})")
        }
        def currentBranch = grgit.branch.current().getName()
        if (currentBranch != 'master') {
            throw new RuntimeException("Need to be on the master branch to release (currently on ${currentBranch})")
        }
        grgit.fetch()
        if (grgit.tag.list().any { it.name == project.version }) {
            throw new RuntimeException("A tag already exists for ${project.version}")
        }
        def status = grgit.branch.status(name: currentBranch)
        if (status.aheadCount != 0) {
            throw new RuntimeException('Some commits have not been pushed')
        }
        if (status.behindCount != 0) {
            throw new RuntimeException('Some commits have not been pulled')
        }
    }
}

githubRelease {
    token "${getProjectProperty('github_releases_token')}"
    // default owner: last component of maven group
    // default repo: name of the project
    tagName = project.version
    targetCommitish = { grgit.branch.current().name }
    body = { project.getChangelogText() }

    FilenameFilter filter = { dir, filename -> filename.contains(project.version) && !filename.contains('-dev.jar') }
    releaseAssets = { jar.destinationDirectory.asFile.get().listFiles filter }
}
tasks.githubRelease.dependsOn(checkGitStatus)

bintray {
    user = project.findProperty('bintray_user')
    key = project.findProperty('bintray_api_key')
    publications = ['mavenJava']
    publish = true //[Default: false] Whether version should be auto published after an upload
    pkg {
        repo = 'mods'
        name = project.name
        userOrg = 'ladysnake'
        version {
            name = project.version
            vcsTag = project.version
            released  = new Date()
        }
    }
}

bintrayUpload.dependsOn(checkGitStatus)
bintrayUpload.dependsOn(build)

curseforge {

    if (project.getProjectProperty('curse_key') != null) {
        apiKey = project.getProjectProperty('curse_key')
    }

    if (project.hasProperty('curseforge_id')) {
        project {
            id = findProperty('curseforge_id')

            releaseType = project.release_type

            //usually automatically determined by the CurseGradle plugin, but won't work with fabric
            "${project.curseforge_versions}".split('; ').each {
                addGameVersion it
            }
            addGameVersion 'Fabric'

            mainArtifact(remapJar) {
                displayName = "${project.name}-${project.version}.jar"

                if (project.hasProperty('cf_requirements') || project.hasProperty('cf_optionals') || project.hasProperty('cf_embeddeds') || project.hasProperty('cf_tools') || project.hasProperty('cf_incompatibles') || project.hasProperty('cf_includes')) {
                    relations {
                        if (project.hasProperty('cf_requirements')) {
                            "${project.cf_requirements}".split('; ').each {
                                requiredDependency "${it}"
                            }
                        }
                        if (project.hasProperty('cf_optionals')) {
                            "${project.cf_optionals}".split('; ').each {
                                optionalDependency "${it}"
                            }
                        }
                        if (project.hasProperty('cf_embeddeds')) {
                            "${project.cf_embeddeds}".split('; ').each {
                                embeddedLibrary "${it}"
                            }
                        }
                        if (project.hasProperty('cf_tools')) {
                            "${project.cf_tools}".split('; ').each {
                                tool "${it}"
                            }
                        }
                        if (project.hasProperty('cf_incompatibles')) {
                            "${project.cf_incompatibles}".split('; ').each {
                                incompatible "${it}"
                            }
                        }
                        if (project.hasProperty('cf_includes')) {
                            "${project.cf_includes}".split('; ').each {
                                include "${it}"
                            }
                        }
                    }
                }
            }

            changelogType = 'markdown'
            changelog = project.getChangelogText()

            subprojects {
                addArtifact(remapJar) {
                    displayName = "${project.name}-${project.version}.jar"
                }
            }

            afterEvaluate {
                uploadTask.dependsOn remapSourcesJar
            }
        }
        options {
            forgeGradleIntegration = false
        }
    }
}

tasks.curseforge.dependsOn(checkGitStatus)

task release(dependsOn: [tasks.publish, tasks.githubRelease, tasks.bintrayUpload, tasks.curseforge]) {
    group = 'publishing'
    description = 'Releases a new version to Maven, Github and Curseforge'
}