build.gradle

import proguard.gradle.ProGuardTask

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.guardsquare:proguard-gradle:7.4.1'
    }
}

plugins {
    id 'org.cadixdev.licenser' version '0.6.1'
    id 'com.github.johnrengelman.shadow' version '7.0.0'
    id 'com.diffplug.spotless' version '6.22.0'
    id 'net.neoforged.gradleutils' version '3.0.0-alpha.11'
    id 'net.neoforged.gradleutils.spotless' version '3.0.0-alpha.11'
    //id 'maven'
    id 'maven-publish'
    id 'java'
    id 'eclipse'
    id 'idea'
}

spotlessUtils.configure(spotless)

repositories {
    mavenCentral()
    maven gradleutils.maven
}

group = 'net.neoforged'
base {
    archivesName = 'legacyinstaller'
}

gradleutils.setupSigning(signAllPublications: true)

gradleutils.version {
    branches {
        suffixBranch()
    }
}

java.toolchain.languageVersion = JavaLanguageVersion.of(8)

license {
  header project.file('LICENSE-header.txt')
  include 'net/minecraftforge/installer/**/*.java'
  newLine false
}

version = gradleutils.version
println('Installer Version: ' + version)

ext {
    SPEC_VERSION = gradleutils.gitInfo.tag
    MAIN_CLASS = 'net.minecraftforge.installer.SimpleInstaller'
    MANIFEST = manifest{
        attributes('Main-Class': MAIN_CLASS)
        attributes([
            'Specification-Title':      'Installer',
            'Specification-Vendor':     'NeoForge',
            'Specification-Version':    SPEC_VERSION,
            'Implementation-Title':     'SimpleInstaller',
            'Implementation-Version':   project.version,
            'Implementation-Vendor':    'NeoForge'
        ] as LinkedHashMap, 'net/minecraftforge/installer/')
    }
}

configurations {
    testInstallerData {
        canBeConsumed = false
        canBeResolved = true
        transitive = false
    }
}

dependencies {
    implementation 'net.sf.jopt-simple:jopt-simple:5.0.4'
    implementation 'com.google.code.gson:gson:2.11.0'
    implementation 'net.neoforged.installertools:cli-utils:2.1.0'
	testImplementation(platform('org.junit:junit-bom:5.7.2'))
	testImplementation('org.junit.jupiter:junit-jupiter')
    compileOnly 'org.jetbrains:annotations:24.1.0'
    testInstallerData 'net.neoforged:neoforge:21.4.10-beta:installer'
}

test {
  useJUnitPlatform()
  testLogging {
    events "passed", "skipped", "failed"
  }
}

compileJava {
    options.encoding = 'UTF-8'
}

java {
    withSourcesJar()
}

shadowJar {
    archiveClassifier = 'fatjar'
    manifest.from(MANIFEST)
}

tasks.register('pgShrinkJar', ProGuardTask) {
    dependsOn shadowJar
    ext {
        inputJar = shadowJar.archiveFile.get().asFile
        outDir = file("${buildDir}/proguard")
        obfuscatedJar = "${outDir}/${jar.archiveBaseName.get()}.jar"
        config = 'proguard.pro'
    }
    inputs.file inputJar
    inputs.file config

    outDir.mkdirs()

    injars inputJar
    outjars obfuscatedJar

    // Automatically handle the Java version of this build.
    if (System.getProperty('java.version').startsWith('1.')) {
        // Before Java 9, the runtime classes were packaged in a single jar file.
        libraryjars "${System.getProperty('java.home')}/lib/rt.jar"
    } else {
        // As of Java 9, the runtime classes are packaged in modular jmod files.
        libraryjars "${System.getProperty('java.home')}/jmods/java.base.jmod", jarfilter: '!**.jar', filter: '!module-info.class'
        libraryjars "${System.getProperty('java.home')}/jmods/java.desktop.jmod", jarfilter: '!**.jar', filter: '!module-info.class'
        libraryjars "${System.getProperty('java.home')}/jmods/java.logging.jmod", jarfilter: '!**.jar', filter: '!module-info.class'
        libraryjars "${System.getProperty('java.home')}/jmods/jdk.unsupported.jmod", jarfilter: '!**.jar', filter: '!module-info.class'
    }
    configuration config
}

tasks.register('shrinkJar', Jar) {
    dependsOn pgShrinkJar
    archiveClassifier = 'shrunk'
    from zipTree(pgShrinkJar.obfuscatedJar)
    manifest.from(MANIFEST)
}

artifacts {
    //archives shadowJar
    archives sourcesJar
    archives shrinkJar
}

jar {
    manifest.from(MANIFEST)
}

processResources {
    exclude 'maven/**'
}

tasks.register('testJar', Jar) {
    dependsOn shrinkJar
    from zipTree(shrinkJar.archiveFile.get().asFile)
    from sourceSets.test.output
    archiveClassifier = 'test'
    manifest.from(MANIFEST)
}

// Combine the shrunk jar with data from the current Neoforge installer
tasks.register('productionTestJar', Jar) {
    group = "build"
    dependsOn shrinkJar
    from zipTree(shrinkJar.archiveFile.get().asFile)
    from(zipTree(configurations.testInstallerData.singleFile)) {
        exclude '/**/*.class'
    }
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    archiveClassifier = 'prodtest'
    manifest.from(MANIFEST)
}

/**
 * Run this installer that contains the data from a real Neoforge installer.
 */
tasks.register('runProductionTest', JavaExec) {
    dependsOn tasks.named("productionTestJar")
    mainClass = "-jar";
    args productionTestJar.archiveFile.get()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact sourcesJar
            artifact shrinkJar
            artifact jar
            pom {
                name = project.archivesBaseName
                packaging = 'jar'
                description = 'NeoForge Forge Installer'
                pomUtils.githubRepo(it, 'LegacyInstaller')
            }
        }
    }
    repositories {
        maven gradleutils.publishingMaven
    }
}