build.gradle

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "org.kohsuke:github-api:1.114"
        classpath "io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.30.0"
    }
}

plugins {
    id 'java-library'
    id 'org.cadixdev.licenser' version '0.5.0'
    id 'signing'
    id 'maven-publish'
}
apply plugin: 'io.codearte.nexus-staging'

sourceCompatibility = JavaVersion.VERSION_16
targetCompatibility = JavaVersion.VERSION_16

archivesBaseName = project.archives_base_name
version = project.version
group = project.maven_group

repositories {
    mavenCentral()
    maven {
        url "https://libraries.minecraft.net"
    }
}

ext.changelog = ""

license {
    header = rootProject.file("LICENSE")
}

dependencies {
    api "com.google.code.gson:gson:2.8.7"
    api "com.mojang:brigadier:1.0.17"
    testImplementation 'org.junit.jupiter:junit-jupiter:5.7.2'
}

test {
    useJUnitPlatform()
    testLogging {
        events "passed", "skipped", "failed", "standard-out", "standard-error"
    }
}

processResources {
    inputs.property "version", project.version

    filesMatching("fabric.mod.json") {
        expand "version": project.version
    }
}

tasks.withType(JavaCompile).configureEach {
    it.options.encoding = "UTF-8"
}

java {
    withSourcesJar()
}

javadoc {
    options {
        links("https://www.javadoc.io/doc/com.google.code.gson/gson/2.8.7",
                "https://docs.oracle.com/en/java/javase/16/docs/api/")
    }
    failOnError false
}

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

jar {
    from("LICENSE") {
        rename { "${it}_${project.archivesBaseName}" }
    }
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact jar
            artifact sourcesJar
            artifact javadocJar

            pom {
                name = 'Json to Brigadier'
                packaging = 'jar'
                description = 'This is a library that converts JSON to brigadier arguments.'
                url = 'https://github.com/OroArmor/json-to-brigadier'

                scm {
                    connection = 'scm:git:git://github.com/OroArmor/json-to-brigadier.git'
                    developerConnection = 'scm:git:ssh://github.com:OroArmor/json-to-brigadier.git'
                    url = 'https://github.com/OroArmor/json-to-brigadier'
                }

                licenses {
                    license {
                        name = 'MIT'
                        url = 'https://mit-license.org/'
                    }
                }

                developers {
                    developer {
                        id = 'OroArmor'
                        name = 'Eli Orona'
                        email = 'eliorona@live.com'
                        url = "oroarmor.com"
                    }
                }
            }
        }
    }

    repositories {
        def ossrhUsername = "OroArmor"
        def ossrhPassword = (project.hasProperty("ossrhPassword") ? project.property("ossrhPassword") : System.getenv("OSSRH_PASSWORD")) as String
        mavenLocal()
        maven {
            def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
            def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
            credentials(PasswordCredentials) {
                username = ossrhUsername
                password = ossrhPassword
            }
            name = "mavenCentral"
        }
    }
}

tasks.withType(Sign) {
    onlyIf { project.hasProperty("sign") }
}

if (project.hasProperty("sign")) {
    signing {
        useGpgCmd()
        sign publishing.publications.getByName("mavenJava")
    }
}

nexusStaging {
    username = "OroArmor"
    password = project.hasProperty("ossrhPassword") ? project.property("ossrhPassword") : System.getenv("OSSRH_PASSWORD")
}

import org.kohsuke.github.GHReleaseBuilder
import org.kohsuke.github.GitHub

task github {
    onlyIf {
        System.getenv().GITHUB_TOKEN
    }

    doLast {
        def github = GitHub.connectUsingOAuth(System.getenv().GITHUB_TOKEN as String)
        def repository = github.getRepository("OroArmor/json-to-brigadier")

        def releaseBuilder = new GHReleaseBuilder(repository, project.version)
        releaseBuilder.name("$project.project_name $project.version")
        releaseBuilder.body(project.ext.changelog)
        releaseBuilder.commitish("master")

        def ghRelease = releaseBuilder.create()
        ghRelease.uploadAsset(file("${project.rootDir}/build/libs/${archivesBaseName}-${version}.jar"), "application/java-archive");
    }
}

task generateChangelog {
    def changelogFile = file("CHANGELOG.md")
    def contents = ""
    changelogFile.withReader { reader ->
        def line
        while ((line = reader.readLine()) != null)
            contents += line + "\n"
    }

    def changelogs = contents.split("----")
    project.ext.changelog = changelogs.find { log -> log.contains(project.version) }
    println project.ext.changelog
}