build.gradle

plugins {
    id 'maven-publish'
    id "io.freefair.jsass-base" version "1.0.2"
    id "com.magnetichq.gradle.js" version "3.0.2"
    id 'net.minecraftforge.gradleutils' version '[2.3,2.4)'
}

group = 'net.minecraftforge'
version = gradleutils.tagOffsetVersion
println "Version: $version"

tasks.register("css", io.freefair.gradle.plugins.jsass.SassCompile) {
    sassPath = "${projectDir}/sass"
    cssPath = "${buildDir}/css"
    sourceMapEnabled = false
    //outputStyle = io.bit3.jsass.OutputStyle.NESTED
    outputStyle = io.bit3.jsass.OutputStyle.COMPRESSED
}
def minifyJsFiles = tasks.register("minifyJsFiles")
void createJsTask(final String taskName, final String fileName) {
    def tmp = tasks.register("minify${taskName.capitalize()}DotJs", com.eriwen.gradle.js.tasks.MinifyJsTask) {
        source = file("${projectDir}/js/${fileName}.js")
        dest = file("${buildDir}/js/${fileName}.min.js")
    }
    minifyJsFiles.dependsOn(tmp)
}
createJsTask('themeSwitch', "theme-switch")
createJsTask('themeSwitchToggle', "theme-switch-toggle")
createJsTask('curseAds', "curse-ads")
createJsTask('googleAds', "google-ads")
createJsTask('sidebar', "sidebar")
createJsTask('files', "files")
tasks.register('bundleStatic', Zip) {
    dependsOn minifyJsFiles
    archiveBaseName = 'static-bundle'
    destinationDirectory = file("${buildDir}/distributions")
    from(file("${buildDir}/js")) {
        include '*.js'
        into 'js'
    }
    from(css) {
        include 'website_*.css'
        into 'css'
        rename ~/website_([A-Za-z]+)/, 'styles_$1'
    }
    from("${projectDir}/css") {
        include '*.css'
        into 'css'
    }
    from("${projectDir}/images") {
        include '**'
        into 'images'
    }
    from("${projectDir}/docs") {
        include '**/*.html'
    }
}
tasks.register('bundleFiles', Zip) {
    dependsOn bundleStatic
    archiveBaseName = 'full-bundle'
    destinationDirectory = file("${buildDir}/distributions")
    from(zipTree(bundleStatic.archiveFile)) {
        into 'static'
    }
    from(file("${projectDir}/python")) {
        exclude '__pycache__/'
        into 'python'
    }
    from(file("${projectDir}/templates")) {
        into 'templates'
    }
    from(file("${projectDir}/requirements.txt"))
}

@groovy.transform.CompileStatic
static String digest(String data, String hash) {
    return java.security.MessageDigest.getInstance(hash).digest(data.bytes).encodeHex().toString()
}
void writeArtifact(group, name, version, classifier = null, String ext = 'jar') {
    String path = "${group}/${name}/${version}/${name}-${version}"
    if (classifier != null)
        path += '-' + classifier
    path += '.' + ext
    file("./test/maven/${path}").parentFile.mkdirs()
    file("./test/maven/${path}").text = path
    file("./test/maven/${path}.md5").text = digest(path, 'MD5')
    file("./test/maven/${path}.sha1").text = digest(path, 'SHA-1')
    file("./test/maven/${path}.sha256").text = digest(path, 'SHA-256')
}
void writeXml(String group, String name, String displayName, List vers, boolean writePromos) {
    final writer = new StringWriter()
    def xml = new groovy.xml.MarkupBuilder(writer)
    String path = "./test/maven/${group}/${name}"
    
    xml.metadata() {
        groupId(group.replace('/', '.'))
        artifactId(name)
        versioning() {
            release(vers[-1])
            latest(vers[-1])
            lastUpdated(20220101010000)
            versions() {
                vers.each { ver -> xml.version(ver) }
            }
        }
    }
    String data = writer.toString()
    file("${path}/").mkdirs()
    file("${path}/maven-metadata.xml").text = data
    file("${path}/maven-metadata.xml.md5").text = digest(data, 'MD5')
    file("${path}/maven-metadata.xml.sha1").text = digest(data, 'SHA-1')
    file("${path}/maven-metadata.xml.sha256").text = digest(data, 'SHA-256')
    file("${path}/page_config.json").text = new groovy.json.JsonBuilder([
            name: displayName,
            comments: false,
            downloads: true,
            shrink_dls: false,
            adfocus: "271228"
    ]).toPrettyString()
    if (writePromos) {
        file("${path}/promotions_slim.json").text = new groovy.json.JsonBuilder([
            homepage: 'https://not_real.invalid/',
            promos: [
                '1.16.5-latest':      '36.1.2',
                '1.16.5-recommended': '36.1.2',
                '1.18.1-latest':      '39.1.2',
                '1.18.1-recommended': '39.1.2',
                '1.18.2-latest':      '40.0.8'
            ]
        ]).toPrettyString()
    }
}
tasks.register("deleteTestData", Delete) {
    delete './test/'
}
tasks.register('generateMaven') {
    mustRunAfter deleteTestData
    doLast {
        List versions = []
        ['1.16.5-36.0', '1.16.5-36.1', '1.18.1-39.0', '1.18.1-39.1', '1.18.2-40.0', '1.18.2-40.1'].each { ver ->
            def range = 0..8 // make eight builds for "beta" release period
            if (ver.endsWith('.1'))
                range = 0..2 // make three builds for "recommended" release period

            range.each { build ->
                versions.add("${ver}.${build}")
                writeArtifact('net/minecraftforge', 'forge', "${ver}.${build}")
                writeArtifact('net/minecraftforge', 'forge', "${ver}.${build}", 'userdev')
                writeArtifact('net/minecraftforge', 'forge', "${ver}.${build}", 'changelog', 'txt')
                writeArtifact('net/minecraftforge', 'forge', "${ver}.${build}", 'mdk', 'zip')
                writeArtifact('net/minecraftforge', 'forge', "${ver}.${build}", 'installer')
            }
        }
        writeXml('net/minecraftforge', 'forge', "Minecraft Forge", versions, true)

        versions = []
        ['23w13a_or_b-april.2023.13.b', '23w17a-2023.17.a', '1.20.1-pre1-46.0', '1.19.4-45.0', '1.20-rc1-46.1'].each { ver ->
            def range = 0..8 // make eight builds

            range.each { build ->
                versions.add("${ver}.${build}")
                writeArtifact('net/minecraftforge', 'froge', "${ver}.${build}")
                writeArtifact('net/minecraftforge', 'froge', "${ver}.${build}", 'userdev')
                writeArtifact('net/minecraftforge', 'froge', "${ver}.${build}", 'changelog', 'txt')
                writeArtifact('net/minecraftforge', 'froge', "${ver}.${build}", 'mdk', 'zip')
                writeArtifact('net/minecraftforge', 'froge', "${ver}.${build}", 'installer')
            }
        }
        writeXml('net/minecraftforge', 'froge', "Minecraft Froge", versions, false)
    }
}
tasks.register('generateGlobalConfig') {
    mustRunAfter deleteTestData
    doLast {
        def file = file('./test/config/global_overrides.json')
        file.parentFile.mkdirs()
        file.text = new groovy.json.JsonBuilder([
            ad_left: "<div id='cdm-zone-01' class='promo-content'></div>",
            ad_middle: "<div id='cdm-zone-03' class='promo-content'></div>",
            ad_right: "<div id='cdm-zone-02' class='promo-content'></div>"
        ]).toPrettyString()
    }
}
tasks.register('generateTestUsers') {
    mustRunAfter deleteTestData
    doLast {
        def file = file('./test/config/users.json')
        file.parentFile.mkdirs()
        file.text = new groovy.json.JsonBuilder([
            test_name: [
                password: 'test_password',
                access: [
                    [group: '', artifact: '']
                ]
            ]
        ]).toPrettyString()
    }
}
tasks.register('generateTestConfig') {
    dependsOn generateGlobalConfig, generateTestUsers
    mustRunAfter deleteTestData
    doLast {
        def cfg = file('./test/config/config.json')
        cfg.parentFile.mkdirs()
        cfg.text = new groovy.json.JsonBuilder([
            promote: [
                args: [ '--folder', '/in', '--local-data', '--config', '/config/global_overrides.json', '--static',  'file://' + file('./test/static/').absolutePath]
            ]
        ]).toPrettyString()
    }
}
tasks.register('extractBundledFiles', Copy) {
    dependsOn bundleStatic
    mustRunAfter deleteTestData
    from zipTree(bundleStatic.archiveFile)
    into file('./test/static/')
}
tasks.register('copyTestTemplates', Copy) {
    mustRunAfter deleteTestData
    from file('./templates/')
    into file('./test/templates/')
}
tasks.register('copyTestPython', Copy) {
    mustRunAfter deleteTestData
    from file('./python/')
    into file('./test/python/')
}
tasks.register('runTestPageGen', Exec) {
    dependsOn = [copyTestPython, copyTestTemplates]
    workingDir 'test'
    String os = System.getProperty('os.name').toLowerCase(Locale.ROOT)
    if (os.contains('win'))
        commandLine 'cmd', '/c', file('runTestPageGen.bat').absolutePath
    else // assume *nix
        commandLine 'sh', '../runTestPageGen.sh'
}
tasks.register('setupPageGen', Exec) {
    String os = System.getProperty('os.name').toLowerCase(Locale.ROOT)
    if (os.contains('win'))
        commandLine 'cmd', '/c', 'pip install -r requirements.txt'
    else // assume *nix
        commandLine 'sh', '-c', 'pip install -r requirements.txt'
}
tasks.register('setupTest') {
    dependsOn = [deleteTestData, extractBundledFiles, generateMaven, setupPageGen, generateTestConfig, copyTestTemplates]
    doLast { file('./test/out').mkdirs() }
}


tasks.register('publishDocker', Exec) {
    dependsOn bundleStatic
    commandLine 'docker-compose', 'build'
    doLast {
        exec { commandLine 'docker', 'tag',  'pagegen:latest', 'containers.minecraftforge.net/pagegen:latest' }
        exec { commandLine 'docker', 'tag',  'pagegen:latest', "containers.minecraftforge.net/pagegen:$version" }
        exec { commandLine 'docker', 'push', 'containers.minecraftforge.net/pagegen:latest' }
        exec { commandLine 'docker', 'push', "containers.minecraftforge.net/pagegen:$version" }
        
        exec { commandLine 'docker', 'tag',  'pagegen-webhook:latest', 'containers.minecraftforge.net/pagegen-webhook:latest' }
        exec { commandLine 'docker', 'tag',  'pagegen-webhook:latest', "containers.minecraftforge.net/pagegen-webhook:$version" }
        exec { commandLine 'docker', 'push', 'containers.minecraftforge.net/pagegen-webhook:latest' }
        exec { commandLine 'docker', 'push', "containers.minecraftforge.net/pagegen-webhook:$version" }
    }
}
tasks.register('publishDockerTest', Exec) {
    dependsOn bundleStatic
    commandLine 'docker-compose', 'build'
    doLast {
        exec { commandLine 'docker', 'tag',  'pagegen:latest', 'containers.minecraftforge.net/pagegen-test:latest' }
        exec { commandLine 'docker', 'tag',  'pagegen:latest', "containers.minecraftforge.net/pagegen-test:$version" }
        exec { commandLine 'docker', 'push', 'containers.minecraftforge.net/pagegen-test:latest' }
        exec { commandLine 'docker', 'push', "containers.minecraftforge.net/pagegen-test:$version" }
        
        
        exec { commandLine 'docker', 'tag',  'pagegen-webhook:latest', 'containers.minecraftforge.net/pagegen-webhook-test:latest' }
        exec { commandLine 'docker', 'tag',  'pagegen-webhook:latest', "containers.minecraftforge.net/pagegen-webhook-test:$version" }
        exec { commandLine 'docker', 'push', 'containers.minecraftforge.net/pagegen-webhook-test:latest' }
        exec { commandLine 'docker', 'push', "containers.minecraftforge.net/pagegen-webhook-test:$version" }
    }
}

publishing {
    publications.register('forgeMaven', MavenPublication) {
        artifact source: bundleFiles, extension: 'zip'

        artifactId = 'web'

        pom {
            name = 'Forge Page Generator'
            description = 'Python code to generate a download frontend for maven repository'
            url = 'https://github.com/MinecraftForge/Web'

            gradleutils.pom.setGitHubDetails(pom, 'Web')

            license gradleutils.pom.Licenses.LGPLv2_1

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

    repositories {
        maven gradleutils.publishingForgeMaven
    }
}