build.gradle

import groovy.json.JsonSlurper
import groovy.transform.EqualsAndHashCode
import groovy.transform.TupleConstructor

plugins {
    id 'java-gradle-plugin'
    id 'maven-publish'
    id 'dev.lukebemish.managedversioning'
    alias cLibs.plugins.gradlepublish
}

group='dev.lukebemish'

managedVersioning {
    versionFile.set project.file('version.properties')
    versionPRs()
    versionSnapshots()

    gitHubActions {
        snapshot {
            prettyName.set 'Snapshot'
            workflowDispatch.set(true)
            onBranches.add 'main'
            gradleJob {
                buildCache()
                cacheReadOnly.set false
                javaVersion.set '21'
                name.set 'build'
                gradlew 'Build', 'build'
                gradlew 'Publish', 'publish'
                mavenSnapshot('github')
            }
        }
        release {
            prettyName.set 'Release'
            workflowDispatch.set(true)
            gradleJob {
                buildCache()
                javaVersion.set '21'
                name.set 'build'
                step {
                    setupGitUser()
                }
                readOnly.set false
                gradlew 'Tag Release', 'tagRelease'
                gradlew 'Build', 'build'
                step {
                    run.set 'git push && git push --tags'
                }
                recordVersion 'Record Version', 'version'
                dependencySubmission()
            }
            gradleJob {
                buildCache()
                javaVersion.set '21'
                name.set 'publishStaging'
                needs.add('build')
                tag.set('${{needs.build.outputs.version}}')
                gradlew 'Publish', 'publish'
                sign()
                mavenStaging('github')
            }
            gradleJob {
                buildCache()
                javaVersion.set '21'
                name.set 'publishCentral'
                needs.add('build')
                tag.set('${{needs.build.outputs.version}}')
                gradlew 'Publish', 'publishCentral', 'closeAndReleaseSonatypeStagingRepository'
                sign()
                mavenCentral()
            }
            gradleJob {
                buildCache()
                javaVersion.set '21'
                name.set 'publishPlugin'
                needs.add('build')
                tag.set('${{needs.build.outputs.version}}')
                gradlew 'Publish', 'publishPlugins'
                sign()
                pluginPortal()
            }
        }
        build_pr {
            prettyName.set 'Build PR'
            pullRequest.set(true)
            gradleJob {
                javaVersion.set '21'
                name.set 'build'
                gradlew 'Build', 'build'
                gradlew 'Publish', 'publish'
                pullRequestArtifact()
            }
        }
        publish_pr {
            prettyName.set 'Publish PR'
            publishPullRequestAction(
                'github',
                "${project.group.replace('.', '/')}/${project.name},${project.group.replace('.', '/')}/${project.name}/tools",
                'Build PR'
            )
        }
    }

    apply()
}

println "Version: ${project.version}"

gradlePlugin {
    website = "https://github.com/lukebemishprojects/crochet/"
    vcsUrl = "https://github.com/lukebemishprojects/crochet.git"

    plugins {
        crochet {
            id = 'dev.lukebemish.crochet'
            displayName = 'Crochet'
            description = 'Tool to set up development environments for Minecraft mods'
            tags.addAll(["minecraft", "fabricmc"])
            implementationClass = 'dev.lukebemish.crochet.internal.CrochetPlugin'
        }
        crochetRepositories {
            id = 'dev.lukebemish.crochet.repositories'
            displayName = 'Crochet'
            description = 'Sets up repositories needed for Crochet, a tool to set up development environments for Minecraft mods'
            tags.addAll(["minecraft", "fabricmc"])
            implementationClass = 'dev.lukebemish.crochet.internal.CrochetRepositoriesPlugin'
        }
        crochetIdeaModel {
            id = 'dev.lukebemish.crochet.idea'
            displayName = 'Crochet'
            description = 'Handles the IDE model for idea for Crochet, a tool to set up development environments for Minecraft mods'
            tags.addAll(["minecraft", "fabricmc", "idea"])
            implementationClass = 'dev.lukebemish.crochet.internal.IdeaModelHandlerPlugin'
        }
    }
}

repositories {
    if (project.useLocalMavenForTesting) {
        mavenLocal()
    }

    mavenCentral()
    gradlePluginPortal()
}

var versions = new Properties()
file("src/main/resources/versions.properties").withInputStream {
    versions.load(it)
}

dependencies {
    compileOnly cLibs.bundles.compileonly
    annotationProcessor cLibs.bundles.annotationprocessor
    implementation 'commons-io:commons-io:2.11.0'
    implementation 'org.apache.commons:commons-text:1.10.0'
    implementation 'com.google.code.gson:gson:2.10'
    implementation 'com.google.guava:guava:33.0.0-jre'
    implementation 'net.neoforged:srgutils:1.0.9'
    implementation 'net.fabricmc:access-widener:2.1.0'
    implementation("dev.lukebemish:taskgraphrunner:${versions.taskgraphrunner}") {
        capabilities {
            requireCapability("dev.lukebemish:taskgraphrunner-model")
        }
    }
}

tasks.named('jar', Jar) {
    manifest {
        attributes(['Implementation-Version': project.version])
    }
}

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(21))
    }
    withSourcesJar()
    withJavadocJar()
}

tasks.withType(AbstractArchiveTask) {
    preserveFileTimestamps = false
    reproducibleFileOrder = true
    dirMode = 0755
    fileMode = 0644
}

abstract class DownloadManifest extends DefaultTask {
    @OutputFile
    abstract RegularFileProperty getOutputFile()

    @javax.inject.Inject
    public DownloadManifest() {
        outputs.upToDateWhen { false }
    }

    @TaskAction
    void execute() {
        def outputFile = outputFile.get().asFile
        outputFile.parentFile.mkdirs()
        outputFile.text = 'https://piston-meta.mojang.com/mc/game/version_manifest_v2.json'.toURL().text
    }
}

abstract class CreateMinecraftLibrariesMavenContent extends DefaultTask {
    @OutputFile
    abstract RegularFileProperty getOutputFile()

    @Input
    abstract Property<String> getClassName()

    @Internal
    abstract DirectoryProperty getOutputSourceDir()

    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    abstract RegularFileProperty getManifestFile()

    @TupleConstructor
    @EqualsAndHashCode
    private static class Module {
        final String group
        final String name
    }

    @javax.inject.Inject
    public CreateMinecraftLibrariesMavenContent() {
        outputFile.convention(outputSourceDir.file(className.map { it.replace('.', '/')+'.java' }))
    }

    @TaskAction
    void execute() {
        final Set<Module> modules = new LinkedHashSet<>()
        final sourceFile = outputFile.get().asFile
        sourceFile.parentFile.mkdirs()
        final json = new JsonSlurper()
        final manifest = json.parse(manifestFile.get().asFile)
        manifest.versions.each { version ->
            final versionData = json.parse((version.url as String).toURL())
            versionData.libraries.each {
                final gav = it.name.split(':')
                modules.add(new Module(gav[0], gav[1]))
            }
        }
        final classText ="""package ${className.get().split(/\./).dropRight(1).join('.')};

import org.gradle.api.artifacts.repositories.RepositoryContentDescriptor;

class ${className.get().split(/\./).last()} {
    static void applyContent(RepositoryContentDescriptor descriptor) {
${modules.collect { "        descriptor.includeModule(\"${it.group}\", \"${it.name}\");" }.join('\n')}
        descriptor.includeGroupAndSubgroups("com.mojang");
    }
}
"""
        sourceFile.text = classText
    }
}

def downloadManifest = tasks.register('downloadManifest', DownloadManifest) {
    outputFile.set(layout.buildDirectory.file("manifest.json"))
}

tasks.register('createMinecraftLibrariesMavenContent', CreateMinecraftLibrariesMavenContent) {
    dependsOn downloadManifest
    className.set('dev.lukebemish.crochet.internal.MinecraftLibrariesMavenContent')
    outputSourceDir.set(project.file('src/generated/java'))
    manifestFile.set(downloadManifest.flatMap { it.outputFile })
}

sourceSets {
    main {
        java {
            srcDir 'src/generated/java'
        }
    }
}

if (System.getenv("GPG_KEY")) {
    project.pluginManager.apply('signing')
    def signing = project.extensions.getByType(SigningExtension)
    managedVersioning.publishing.sign(signing, publishing)
}


managedVersioning.publishing.mavenStaging(publishing)
managedVersioning.publishing.mavenCentral()
managedVersioning.publishing.mavenPullRequest(publishing)
managedVersioning.publishing.mavenSnapshot(publishing)