build.gradle

import com.matyrobbrt.gradle.jarinjar.task.ForgeJarInJarTask

plugins {
    id 'java-library'
    id 'eclipse'
    id 'idea'
    id 'groovy'
    id 'signing'
    id 'maven-publish'
    id 'com.matyrobbrt.jarinjar' version '1.2.0'
    id 'net.neoforged.moddev' version '2.0.37-beta'
    id 'org.groovymc.modsdotgroovy' version '2.0.0-beta.30'
    id 'io.github.gradle-nexus.publish-plugin' version '2.0.0'
    id 'dev.lukebemish.managedversioning' version '1.2.19'
}

group = 'org.groovymc.gml'

base {
    archivesName = 'gml-core'
}

java.withSourcesJar()

managedVersioning {
    versionFile.set rootProject.file('version.properties')

    gitHubActions {
        release {
            prettyName.set 'Release'
            workflowDispatch.set(true)
            gradleJob {
                name.set 'build'
                javaVersion.set '21'
                step {
                    setupGitUser()
                }
                readOnly.set false
                gradlew 'Tag Release', 'tagRelease'
                gradlew 'Build', 'build'
                step {
                    run.set 'git push && git push --tags'
                }
                recordVersion 'Record Version', 'version'
                secret('CENTRAL_MAVEN_USER')
                secret('CENTRAL_MAVEN_PASSWORD')
                secret('GPG_SIGNING_KEY')
                secret('GPG_KEY_PASSWORD')
            }
            gradleJob {
                name.set 'publish'
                javaVersion.set '21'
                needs.add('build')
                tag.set('${{needs.build.outputs.version}}')
                gradlew 'Publish', 'publish', 'closeAndReleaseSonatypeStagingRepository'
                secret('CENTRAL_MAVEN_USER')
                secret('CENTRAL_MAVEN_PASSWORD')
                secret('GPG_SIGNING_KEY')
                secret('GPG_KEY_PASSWORD')
            }
        }
    }
}

managedVersioning.apply()

println "Building: $version"

// Mojang ships Java 17 to end users in 1.18+, so your mod should target Java 17.
java.toolchain.languageVersion = JavaLanguageVersion.of(21)

sourceSets {
    register('transform')
    register('extension')
    main {
        modsDotGroovy.disable()
    }
    test {
        modsDotGroovy.enable()
    }
}

sourceSets.each {
    def localRuntime = configurations.maybeCreate(it.getTaskName(null, 'localRuntime'))
    configurations.named(it.runtimeClasspathConfigurationName).configure {
        extendsFrom localRuntime
    }
}

configurations {
    include
    groovy {
        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_RUNTIME))
        }
    }
    compileOnlyApi.extendsFrom(groovy)
    testCompileOnly.extendsFrom(groovy)
    extensionCompileOnly.extendsFrom(groovy)
    transformCompileOnly.extendsFrom(groovy)

    javadocElements {
        canBeConsumed = true
        canBeResolved = false
        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_RUNTIME))
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, Category.DOCUMENTATION))
            attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.class, Bundling.EXTERNAL))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType.class, DocsType.JAVADOC))
        }
    }
}

tasks.register('fullJar', ForgeJarInJarTask)

neoForge {
    version = '21.0.14-beta'
    addModdingDependenciesTo(sourceSets.test)
    addModdingDependenciesTo(sourceSets.extension)
    addModdingDependenciesTo(sourceSets.transform)
    mods {
        gml {
            sourceSet(sourceSets.test)
        }
    }
	runs {
		client {
			client()
		}
	}
}

dependencies {
    transformCompileOnly(sourceSets.main.output)
    compileOnly(testCompileOnly(sourceSets.extension.output))
    testCompileOnly(sourceSets.transform.output)

    groovy "org.groovymc:groovybundler:${project.groovybundler_version}"
    include("org.groovymc:groovybundler:${project.groovybundler_version}") {
        transitive = false
    }

    testImplementation(project.files(tasks.named('fullJar')) {
        builtBy(tasks.named('fullJar'))
    })
}

sourceSets.each {
    tasks.named(it.compileJavaTaskName, JavaCompile).configure {
        options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
    }
}

final manifestAttr = [
        'Specification-Title'   : 'GroovyModLoader - Core',
        'Specification-Vendor'  : 'GroovyMC',
        'Specification-Version' : 1,
        'Implementation-Title'  : project.name,
        'Implementation-Version': project.version,
        'Implementation-Vendor' : 'GroovyMC',
        'GitCommit'             : managedVersioning.hash,
        'FMLModType'            : 'LIBRARY',
        'Automatic-Module-Name': 'org.groovymc.gml.core'
]

tasks.named('jar', Jar).configure {
    from sourceSets.extension.output
    from sourceSets.transform.output
    manifest.attributes(manifestAttr)
    archiveClassifier = 'slim'
}

tasks.named('sourcesJar', Jar).configure {
    from sourceSets.extension.allSource
    from sourceSets.transform.allSource
}

tasks.named('fullJar', ForgeJarInJarTask).configure {
    from(sourceSets.main.output)
    from(sourceSets.transform.output)
    from(sourceSets.extension.output)
    manifest.attributes(manifestAttr)
    archiveClassifier.set('')
    group('build')
    fromConfiguration(project.configurations.include)

    tasks.build.dependsOn(it)
}

afterEvaluate {
    tasks.runClient.dependsOn(tasks.fullJar)
}

/*project(':script-mods').afterEvaluate {
    rootProject.tasks.named('fullJar', ForgeJarInJarTask) {
        fromJar(project(':script-mods').tasks.shadowJar as org.gradle.jvm.tasks.Jar) { versionRange nextMajor }
    }
}*/

tasks.withType(GroovyCompile).configureEach { GroovyCompile task ->
    task.groovyOptions.fork = true
    task.groovyOptions.encoding = 'UTF-8'
    task.groovyOptions.optimizationOptions.indy = true
}

groovydoc {
    source sourceSets.extension.allSource
    source sourceSets.transform.allSource
    use = true
}

tasks.register('groovydocJar', Jar) {
    archiveClassifier = 'javadoc'
    from groovydoc.destinationDir
    dependsOn(groovydoc)
}

configurations.runtimeElements.artifacts.clear()
configurations.apiElements.artifacts.clear()

artifacts {
    javadocElements groovydocJar
    runtimeElements fullJar
    apiElements fullJar
}

project.components.named("java").configure {
    AdhocComponentWithVariants javaComponent = (AdhocComponentWithVariants) it
    javaComponent.addVariantsFromConfiguration(configurations.javadocElements) {}
}

void sharedMetadata(MavenPom it) {
    it.packaging = 'jar'
    it.url = 'https://github.com/GroovyMC/GroovyModLoader'
    it.inceptionYear = '2022'
    it.licenses {
        license {
            name = 'MIT'
            url = 'https://opensource.org/license/mit/'
        }
    }
    it.developers {
        developer {
            id = 'groovymc'
            name = 'GroovyMC'
            email = 'holdings@groovymc.org'
            url = 'https://github.com/GroovyMC/'
        }
    }
    it.scm {
        connection='scm:git:git://github.com/GroovyMC/GroovyModLoader.git'
        url='https://github.com/GroovyMC/GroovyModLoader'
    }
}

nexusPublishing {
    repositories {
        sonatype {
            username.set(System.getenv('CENTRAL_MAVEN_USER') ?: '')
            password.set(System.getenv('CENTRAL_MAVEN_PASSWORD') ?: '')
            nexusUrl.set(uri("https://s01.oss.sonatype.org/service/local/"))
        }
    }
}

publishing {
    publications {
        register('mavenJava', MavenPublication) {
            from components.java
            it.artifactId = base.archivesName.get()

            pom {
                name = 'GML'
                description = 'The core component of a language provider for NeoForge mods for Groovy'
                sharedMetadata(it)
            }
        }
    }
    repositories {
        maven {
            name 'repo'
            url file('repo')
        }
    }
}

if (System.getenv('GPG_SIGNING_KEY')) {
    signing {
        final signingKey = System.getenv('GPG_SIGNING_KEY') ?: ''
        final signingPassword = System.getenv('GPG_KEY_PASSWORD') ?: ''
        useInMemoryPgpKeys(signingKey, signingPassword)
        sign publishing.publications.mavenJava
    }
}