build.gradle

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import com.github.jengelman.gradle.plugins.shadow.transformers.PropertiesFileTransformer

plugins {
    id 'java'
    id 'eclipse'
    id 'maven-publish'
    alias libs.plugins.gradleutils
    alias libs.plugins.gitversion
    alias libs.plugins.changelog
    alias libs.plugins.licenser
    alias libs.plugins.shadow
}

gradleutils.displayName = 'Installer'
group = 'net.minecraftforge'
version = gitversion.tagOffset
println "Version: $version"

repositories {
    mavenCentral()
    maven gradleutils.forgeMaven
}

license {
    header = file('LICENSE-header.txt')
    newLine = false
}

java {
    toolchain.languageVersion = JavaLanguageVersion.of(8)
    withSourcesJar()
}

configurations {
    multirelease {
        extendsFrom implementation
        canBeConsumed = true
        canBeResolved = false
        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, 'multi-release'))
        }
    }
}

dependencies {
    implementation(libs.jopt.simple)
    implementation(libs.gson)
}

// This isn't great, but it alows us to drop a existing jar file into the root folder and do some debugging
def testJars = fileTree(dir: projectDir).matching{ include '*-installer.jar' }    
if (testJars.files.size() == 1) {
    logger.lifecycle("Detected test installer: ${testJars.singleFile.name}")
    def testData = tasks.register('testData', Jar) {
        from(zipTree(testJars.singleFile)) {
            exclude('**/*.class')
            exclude('META-INF/**')
            exclude('joptsimple/**')
        }
        includeEmptyDirs = false
        archiveClassifier = 'test-data'
    }
    dependencies.implementation(files(testData))
}

tasks.named('jar', Jar) {
    manifest {
        attributes('Main-Class': 'net.minecraftforge.installer.SimpleInstaller')
        attributes([
            'Specification-Title':    'Installer',
            'Specification-Vendor':   'Forge Development LLC',
            'Specification-Version':   gitversion.info.tag,
            'Implementation-Title':   'SimpleInstaller',
            'Implementation-Vendor':  'Forge Development LLC',
            'Implementation-Version':  project.version
        ] as LinkedHashMap, 'net/minecraftforge/installer/')
    }
}

def multiReleaseJar = tasks.register('multiReleaseJar', Jar) {
    manifest {
        from(tasks.named('jar').get().manifest)
        attributes(['Multi-Release': 'true'])
    }
    archiveClassifier = 'multi-release'
    from(zipTree(tasks.named('jar', Jar).flatMap { it.archiveFile }))
}

def addRelease = version -> {
    var cfg = configurations.register('java' + version) {
        transitive = false
    }
    dependencies.add('java' + version, project(':installer-java' + version))
    
    multiReleaseJar.configure {
        from(cfg.map{ zipTree(it.singleFile) }) {
            into('META-INF/versions/' + version)
            exclude('META-INF/**')
            includeEmptyDirs = false
        }
    }
}
addRelease(9)


tasks.named('shadowJar', ShadowJar) {
    archiveClassifier = 'fatjar'
    minimize()
    
    // Add out multi-release elements
    from(multiReleaseJar.map{ zipTree(it.archiveFile) }) {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }
    
    // Meta stuff we don't need
    exclude('com/google/errorprone/**')
    exclude('META-INF/maven/**')
    exclude('META-INF/proguard/**')
    
    // We shouldn't ever need to care about conflicts as this is an executable jar, but just be safe
    relocate('joptsimple', 'net.minecraftforge.installer.shadow.joptsimple')
    relocate('com.google.gson', 'net.minecraftforge.installer.shadow.gson')
    
    // Rewrite JOpt's message files, so that help text is displayed nicely.
    transform(PropertiesFileTransformer) {
        paths = [ 'Messages.properties$' ]
        keyTransformer = { key -> 'net.minecraftforge.installer.shadow.' + key }
    }
}

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

artifacts {
    multirelease multiReleaseJar
}

changelog {
    fromBase()
}

publishing {
    publications.register('mavenJava', MavenPublication) {
        changelog.publish(it)
        gradleutils.promote(it)

        from components.java
        artifact multiReleaseJar

        artifactId = 'installer'

        pom {
            name = 'Installer'
            description = 'Minecraft Forge Installer'
            url = 'https://github.com/MinecraftForge/Installer'

            gradleutils.pom.addRemoteDetails(pom)

            license gradleutils.pom.licenses.LGPLv2_1

            developers {
                developer gradleutils.pom.developers.LexManos
            }
        }
    }

    repositories {
        maven gradleutils.publishingForgeMaven
    }
}