build.gradle

plugins {
    id 'scala'
    id 'maven-publish'
    id 'org.ajoberstar.grgit' version '5.0.0-rc.3'
    id 'com.github.johnrengelman.shadow' version '7.1.2'
    id 'net.minecraftforge.gradle' version '5.1.+'
}

version = getVersion()
group = 'net.minecraftforge'

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

sourceSets {
    example {}
}

minecraft {
    // the mappings can be changed at any time, and must be in the following format.
    // snapshot_YYYYMMDD   snapshot are built nightly.
    // stable_#            stables are built at the discretion of the MCP team.
    // Use non-default mappings at your own risk. they may not always work.
    // simply re-run your setup task after changing the mappings to update your workspace.
    mappings channel: 'official', version: "${mc_version}"

    runs {
        client {
            // recommended logging data for a userdev environment
            properties 'forge.logging.markers': 'REGISTRIES'
            // recommended logging level for the console
            properties 'forge.logging.console.level': 'debug'
            workingDirectory project.file('run').canonicalPath

            mods {
                scorge {
                    source sourceSets.main
                }
                scorgetest {
                    source sourceSets.example
                }
            }
        }
        server {
            // recommended logging data for a userdev environment
            properties 'forge.logging.markers': 'REGISTRIES'
            // recommended logging level for the console
            properties 'forge.logging.console.level': 'debug'
            workingDirectory project.file('run').canonicalPath

            mods {
                scorge {
                    source sourceSets.main
                }
                scorgetest {
                    source sourceSets.example
                }
            }
        }
        
        project.afterEvaluate {
            // Fix scala's broken module artifacts
            def path = configurations.minecraftLibrary.resolvedConfiguration
                    .resolvedArtifacts
                    .findAll { it.moduleVersion.id.group == 'org.scala-lang' }
                    .collect { it.file.name }
                    .join(',')
            configureEach { run -> 
                run.property('mergeModules', path)
            }
        }
    }
}

configurations {
    shade
    minecraftLibrary.extendsFrom shade
    apiElements.extendsFrom shade
    exampleImplementation.extendsFrom implementation
}

repositories {
    mavenCentral()
}

dependencies {
    minecraft "net.minecraftforge:forge:${mc_version}-${forge_version}"
    
    shade "org.scala-lang:scala3-library_3:${scala_lib}"
}

jar {
    archiveClassifier.set('slim')
    manifest {
        attributes([
                'FMLModType': 'LANGPROVIDER',
                'Automatic-Module-Name': 'scorge'
        ])

        attributes(['Specification-Title': 'Mod Language Provider',
                    'Specification-Vendor': 'Forge',
                    'Specification-Version': '1.0',
                    'Implementation-Title': 'Scorge',
                    'Implementation-Version': getVersion(),
                    'Implementation-Vendor' :'Scorge',
                    'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                    'Git-Commit': grgit.head().abbreviatedId,
                    'Git-Branch': grgit.branch.current().getName() ],
                'net/minecraftforge/scorge/lang/')
    }
}

shadowJar {
    classifier = ''
    configurations = [ project.configurations.shade ]
}

tasks.whenTaskAdded {
    // Fight ForgeGradle and Forge crashing when MOD_CLASSES don't exist
    if (name == "prepareRuns") {
        doFirst {
            sourceSets.main.output.files.forEach(File::mkdirs)
        }
    }
}

tasks.assemble.dependsOn shadowJar

afterEvaluate {
    // ShadowRuntimeElements takes care of the runtime variant, we don't need the default one
    components.java.withVariantsFromConfiguration(configurations.runtimeElements) { skip() }
}

publishing {
    publications {
        maven(MavenPublication) { publication ->
            from components.java

            pom {
                name = 'Scorge'
                description = 'The offical Scala language loader for Forge'
                url = 'https://github.com/MinecraftForge/Scorge/'
                scm {
                    url = 'https://github.com/MinecraftForge/Scorge'
                    connection = 'scm:git:git://github.com/MinecraftForge/scorge.git'
                    developerConnection = 'scm:git:git@github.com:MinecraftForge/scorge.git'
                }
                issueManagement {
                    system = 'github'
                    url = 'https://github.com/MinecraftForge/Scorge/issues'
                }

                licenses {
                    license {
                        name = 'LGPLv2.1'
                        url = 'https://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt'
                    }
                }

                developers {
                    developer {
                        id = 'illyohs'
                        name = 'Anthony Anderson'
                    }
                }
            }
        }
    }
    repositories {
        maven {
            credentials {
                username project.properties.forgeMavenUser?:'fake'
                password project.properties.forgeMavenPassword?:'news'
            }
            url 'http://maven.minecraftforge.net/manage/upload'
        }
    }
}

def getVersion()
{
    String base_number = "${mod_version}"
    if (System.hasProperty("BUILD_NUMBER").toString())
    {
        return base_number + "." + System.getenv("BUILD_NUMBER").toString()
    } else {
        return base_number + ".${grgit.head().abbreviatedId}"
    }
}