build.gradle

buildscript {
    repositories {
        maven { url = 'https://maven.minecraftforge.net' }
        maven { url = 'https://repo.spongepowered.org/maven' }
        mavenCentral()
        maven { url = 'https://maven.parchmentmc.org' }
    }
    dependencies {
        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1+', changing: true
        classpath group: 'org.spongepowered', name: 'mixingradle', version: '0.7-SNAPSHOT'
        classpath 'org.parchmentmc:librarian:1.+'
    }
}

plugins {
    id 'com.diffplug.spotless' version '6.22.0'
}

apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'org.parchmentmc.librarian.forgegradle'
apply plugin: 'org.spongepowered.mixin'
apply plugin: 'eclipse'
apply plugin: 'maven-publish'
apply plugin: 'pmd'

ext.configFile = file('build.properties')
ext.config = parseConfig(configFile)

version = "${config.version}-${config.build_number}"
group = "vazkii.${config.mod_id}" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
archivesBaseName = config.mod_name

compileJava.options.compilerArgs << "-Xlint:all,-classfile,-processing,-deprecation"

java.toolchain.languageVersion = JavaLanguageVersion.of(17)
println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))

if (System.getenv('BUILD_NUMBER') != null) {
    version += "." + System.getenv('BUILD_NUMBER')
}

minecraft {
    mappings channel: "${config.mapping_channel}", version: "${config.mapping_version}"
    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.

    accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')

    // Default run configurations.
    // These can be tweaked, removed, or duplicated as needed.
    runs {
        client {
            workingDirectory project.file('run')
            mods {
                psi {
                    source sourceSets.main
                }
            }
        }

        server {
            workingDirectory project.file('run')
            mods {
                psi {
                    source sourceSets.main
                }
            }
        }

        data {
            properties 'forge.logging.console.level': 'debug'
            properties 'fml.earlyprogresswindow': 'false'
            workingDirectory project.file('run')
            mods {
                psi {
                    source sourceSets.main
                }
            }
            args '--mod', 'psi', '--all',
                    '--existing', file('src/main/resources/'),
                    '--output', file('src/generated/resources/')
        }
    }
}

mixin {
    add sourceSets.main, 'psi.refmap.json'
    config 'psi.mixins.json'
}

repositories {
    mavenCentral()
    maven {
        // for Patchouli and JEI
        name "blamejared"
        url "https://maven.blamejared.com/"
        content {
            includeGroup "vazkii.patchouli"
            includeGroup "mezz.jei"
        }
    }
}


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

    annotationProcessor 'org.spongepowered:mixin:0.8.5:processor'

    compileOnly fg.deobf("vazkii.patchouli:Patchouli:${config.patchy_version}:api")
    runtimeOnly fg.deobf("vazkii.patchouli:Patchouli:${config.patchy_version}")

    compileOnly fg.deobf("mezz.jei:jei-${config.mc_version}-common-api:${config.jei_version}")
    compileOnly fg.deobf("mezz.jei:jei-${config.mc_version}-forge-api:${config.jei_version}")
    runtimeOnly fg.deobf("mezz.jei:jei-${config.mc_version}-forge:${config.jei_version}")
}

if (System.getProperty("idea.sync.active") == "true") {
    afterEvaluate {
        tasks.withType(JavaCompile).all {
            it.options.annotationProcessorPath = files()
        }
    }
}

spotless {
    enforceCheck = false // workaround around jenkins having wrong line endings in some files
    java {
        target project.fileTree(dir: 'src/main/java/vazkii/psi', include: '**/*.java')
        //indentWithTabs()
        eclipse().configFile 'spotless/eclipseformat.xml'
        removeUnusedImports()
        importOrderFile 'spotless/eclipse.importorder'
        replaceRegex 'Too much space after if', '(if|for|while|switch) +\\(', '$1('
    }
}

pmd {
    toolVersion '6.42.0'
    incrementalAnalysis.set(true)
    ruleSets.clear()
    ruleSetFiles = files("spotless/pmd-ruleset.xml")
}

task checkSyntax (group: "verification") {
    // Replace the following line when Spotless is setup
    //dependsOn spotlessJavaCheck, pmdMain
    dependsOn pmdMain
}

sourceSets.main.resources {
    srcDir 'src/generated/resources'
}

processResources {
    // copy everything excluding psd files
    from(sourceSets.main.resources.srcDirs) {
        exclude '**/psd/**'
        duplicatesStrategy 'include'
    }
}

task incrementBuildNumber {
    doFirst {
        config.build_number = (config.build_number.toString().toInteger()) + 1
        configFile.withWriter {
            config.toProperties().store(it, "")
        }
    }

    //file('web/versions.ini').append("\n${version}=${minecraft.version}")
    //file("${config.dir_repo}/version/${minecraft.version}.txt").write("${version}")
}

import java.util.regex.Pattern
task sortArtifacts(type: Copy) {
    from jar.destinationDir
    into config.dir_output
    //Put each jar with a classifier in a subfolder with the classifier as its name
    eachFile {
        //This matcher is used to get the classifier of the jar
        def matcher = Pattern.compile(Pattern.quote("$config.mod_name-$version") + "-(?<classifier>\\w+).jar").matcher(it.name)
        //Only change the destination for full matches, i.e jars with classifiers
        if (matcher.matches())
        {
            def classifier = matcher.group('classifier')
            /* Set the relative path to change the destination, since
             * Gradle doesn't seem to like the absolute path being set*/
            it.relativePath = it.relativePath.parent.append(false, classifier, it.name)
        }
    }
}

def parseConfig(File config) {
    config.withReader {
        def prop = new Properties()
        prop.load(it)
        return (new ConfigSlurper().parse(prop))
    }
}

jar {
    //rename the default output, for some better... sanity with scipts
    archiveName = "${baseName}-${version}.${extension}"

     manifest {
        attributes([
            "Specification-Title": "${config.mod_id}",
            "Specification-Vendor": "vazkii",
            "Specification-Version": "1", // We are version 1 of ourselves
            "Implementation-Title": "${config.mod_id}",
            "Implementation-Version": "${version}",
            "Implementation-Vendor" :"vazkii",
            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
            "MixinConfigs": "psi.mixins.json"
        ])
    }

    exclude "**/*.bat"
    exclude "**/*.psd"
    exclude "**/*.exe"
    exclude "**/unused"
    exclude "**/genscripts"
}

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

task deobfJar(type: Jar) {
    classifier = "deobf"
    from sourceSets.main.output
}

artifacts {
    archives sourcesJar
    archives deobfJar
}

publish.dependsOn(project.tasks.getByName("assemble"))
publish.mustRunAfter(project.tasks.getByName("build"))

publishing {

    publications {

        mavenJava(MavenPublication) {

            groupId project.group
            artifactId project.archivesBaseName
            version project.version
            from components.java

            // Allows the maven pom file to be modified.
            pom.withXml {

                // Go through all the dependencies.
                asNode().dependencies.dependency.each { dep ->

                    println 'Surpressing artifact ' + dep.artifactId.last().value().last() + ' from maven dependencies.'
                    assert dep.parent().remove(dep)
                }
            }

            artifact sourcesJar {
                classifier 'sources'
            }
        }
    }

    repositories {
        maven {
            url "file://" + System.getenv("local_maven")
        }
    }
}

// Disables Gradle's custom module metadata from being published to maven. The
// metadata includes mapped dependencies which are not reasonably consumable by
// other mod developers.
tasks.withType(GenerateModuleMetadata) {

    enabled = false
}