build.gradle

// JSettlers build script for gradle 6 or 7
// See bottom of file for copyright and license information (GPLv3).

apply plugin: 'java'
apply plugin: 'application'
apply plugin: 'idea'

buildscript {
    repositories {
        mavenCentral()
    }
}

version = '2.7.00'  // same as in src/main/resources/resources/version.info
ext.i18neditor_version = '1.2.1'  // for PTE editor; same as in src/main/resources/pteResources/pteversion.properties
ext.git_revision = '?'  // placed in jar manifests as Build-Revision attrib; will be filled in by findGitRevision task

mainClassName = "soc.client.SOCPlayerClient"

compileJava {
    sourceCompatibility = '1.8'
    targetCompatibility = '1.8'
}

ext.python_command = findPythonOrPython3()  // python3 or python expected to be in PATH

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'junit:junit:4.13.1'
    implementation 'com.google.code.gson:gson:2.8.6'  // optional at runtime, for savegame feature
        // If version changes, update Readme.developer.md and jsserver.properties.sample
        // Same version is used by v3 branch (dependency of protobuf-java-util)
}

sourceSets {
    extraTest {
        // also runs extraTest/python/*.py, see task extraTaskPython below
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += test.output + test.runtimeClasspath
            srcDirs = ['src/extraTest/java']
        }
        // if needed later: resources.srcDir file('src/extraTest/resources')
    }
}

configurations {
    extraTestImplementation.extendsFrom testImplementation
    extraTestRuntimeOnly.extendsFrom testRuntimeOnly
}

tasks.withType(JavaCompile) {
    options.warnings = true  // don't hide xlint warnings
    options.compilerArgs += '-Xlint:classfile,empty,fallthrough,finally,options,processing,unchecked,varargs'
    options.encoding = 'UTF-8'  // override the system's default encoding
        // To test that this has an effect, use 'Cp1252' instead here and expect "unmappable character" errors in StringUtil.java
}

// unit tests

// run all python unit tests, using PyUnit (unittest module); returns 0 if no failures
task testPython(type: Exec) {
    executable python_command
    workingDir 'src/test/python'
    args '-m', 'unittest', 'discover'  // discover requires python 2.7 or higher
    environment CLASSPATH: tasks.test.classpath.asPath
}

// Make sure sql scripts template token data is self-consistent:
// If test_token_consistency.py finds problems, it will print a detail message.
task testSrcDBTemplateTokens(type: Exec) {
    executable python_command
    workingDir 'src/main/bin/sql/template'
    args 'test_token_consistency.py', new File(sourceSets.main.java.srcDirs[0], '/soc/server/database/SOCDBHelper.java').absolutePath
    outputs.upToDateWhen { false }  // never skip this test
}

// Make sure sql scripts are consistent with their template:
// If render.py finds problems, it will print a message showing which script(s) must be regenerated.
task testSrcDBTemplates(type: Exec) {
    executable python_command
    workingDir 'src/main/bin/sql/template'
    args 'render.py', '-i', 'jsettlers-tables-tmpl.sql', '-d', 'mysql,sqlite,postgres', '-c', '../jsettlers-tables-%s.sql'
    outputs.upToDateWhen { false }  // never skip this test
}


tasks.withType(Test) { task ->
    task.outputs.upToDateWhen { false }  // never skip testing ("UP-TO-DATE") when it's asked for or is dependency
    task.afterSuite { desc, result ->
        if (! desc.parent) {
            // print overall results only
            // Testing results: :test SUCCESS (62 tests, 62 successes, 0 failures, 0 skipped)
            logger.lifecycle("Testing results: {} {} ({} tests, {} successes, {} failures, {} skipped)", task.path,
                result.resultType, result.testCount, result.successfulTestCount, result.failedTestCount, result.skippedTestCount)
        }
    }
}

test.dependsOn ([testSrcDBTemplateTokens, testSrcDBTemplates])
test.finalizedBy testPython  // run java tests first; run python tests even if java fails

// jars

// note: this task runs during configuration
task findGitRevision {
    def cmd = "git rev-parse --short HEAD"
    try {
        def proc = cmd.execute()
        project.ext.git_revision = proc.text.trim()
    } catch (Exception e) {
        // fail gracefully: continue build with git_revision = '?'
        project.logger.lifecycle("warning: findGitRevision can't execute git rev-parse; using '?'")
    }
}

tasks.withType(Jar) {
    includeEmptyDirs = false
    dependsOn findGitRevision
}

// prevent default jsettlers.git-<version>.{jar,zip,.tar.gz} artifact creation;
// various tasks will build artifacts with more specific names and contents instead
jar.enabled = false       // instead build serverJar, fullJar, i18neditorJar
distZip.enabled = false   // dist builds distFullZip
distTar.enabled = false   // dist builds distSrcTar, distFullTar

task serverJar(type: Jar) {
    archiveBaseName = 'JSettlersServer'
    archiveVersion = project.version
    manifest {
        attributes(
            'Main-Class': 'soc.server.SOCServer',
            'Implementation-Version': project.version,
            'Build-Revision': project.git_revision,
            'Class-Path': 'gson.jar',
        )
    }
    from(sourceSets.main.output) {
        include "net/nand/util/i18n/mgr/**"
        include "soc/baseclient/**"
        include "soc/debug/**"
        include "soc/disableDebug/**"
        include "soc/game/**"
        include "soc/message/**"
        include "soc/robot/**"
        include "soc/server/**"
        include "soc/util/**"
    }
    from(sourceSets.main.resources) {
        include "resources/version.info"
        include "resources/strings/server/**"
    }
}

task fullJar(type: Jar) {
    archiveBaseName = 'JSettlers'
    archiveVersion = project.version
    manifest {
        attributes(
            'Main-Class': 'soc.client.SOCPlayerClient',
            'Implementation-Version': project.version,
            'Build-Revision': project.git_revision,
            'Class-Path': 'gson.jar',  // in case client launches a server, or another project uses fullJar
        )
    }
    from(sourceSets.main.output) {
        include "net/nand/util/i18n/mgr/**"
        include "soc/baseclient/**"
        include "soc/client/**"
        include "soc/debug/**"
        include "soc/disableDebug/**"
        include "soc/game/**"
        include "soc/message/**"
        include "soc/robot/**"
        include "soc/server/**"
        include "soc/util/**"
    }
    from(sourceSets.main.resources) {
        include "resources/**"
    }
}

// PropertiesTranslatorEditor utility; not built by default
task i18neditorJar(type: Jar) {
    archiveBaseName = 'PTE'
    archiveVersion = project.i18neditor_version
    manifest {
        attributes(
            'Main-Class': 'net.nand.util.i18n.gui.PTEMain',
            'Implementation-Version': project.i18neditor_version,
            'Build-Revision': project.git_revision,
        )
    }
    from(sourceSets.main.output) {
        include "net/nand/util/i18n/**"  // i18n string manager, parser/writer, editor gui
    }
    from(sourceSets.main.resources) {
        include "pteResources/**"   // for pteversion.properties, strings/**
    }
    from('src/main/java/net/nand/util/i18n/') {
       include 'README.txt'  // into root directory of jar
    }
}

// distribution tgzs and zip

//   these include **/.gitignore files (see settings.gradle)

task cleanRemovePyc(type: Delete) {
    outputs.upToDateWhen { false }  // never skip if asked for
    delete fileTree('src') {
        include '**/*.pyc'
    }
}

// This copies everything in your "src" directory, so be sure to run on a clean repository only!
// Includes target/lib/ to prevent eclipse ant import error
FileTree srcTree = fileTree(dir: '.', includes: ['src/**', 'doc/**', 'build.*', 'Readme.*', '*.txt', '.gitignore', 'target/lib/.gitignore'])

// Naming reminder: [archiveBaseName]-[archiveAppendix]-[archiveVersion]-[archiveClassifier].[archiveExtension]

// jsettlers-2.x.xx-src.tar.gz
task distSrcTar(type: Tar) {
    dependsOn cleanRemovePyc
    archiveBaseName = 'jsettlers'
    archiveClassifier = 'src'
    compression = Compression.GZIP
    archiveExtension = 'tar.gz'
    from srcTree
    into 'jsettlers-' + project.version + '-src/'
}

// jsettlers-2.x.xx-full.tar.gz
task distFullTar(type: Tar) {
    dependsOn cleanRemovePyc
    archiveBaseName = 'jsettlers'
    archiveClassifier = 'full'
    compression = Compression.GZIP
    archiveExtension = 'tar.gz'
    from srcTree, fullJar.outputs.files, serverJar.outputs.files
    into 'jsettlers-' + project.version + '/'
}

// jsettlers-2.x.xx-full.zip
task distFullZip(type: Zip) {
    dependsOn cleanRemovePyc
    archiveBaseName = 'jsettlers'
    archiveClassifier = 'full'
    from srcTree, fullJar.outputs.files, serverJar.outputs.files
    into 'jsettlers-' + project.version + '/'
}

tasks.withType(AbstractArchiveTask) {
    reproducibleFileOrder = true
}

// For dist, ensure no git-untracked files or uncommited changes in repo
task distCheckSrcDirty {
    dependsOn cleanRemovePyc  // prevent "Untracked files in repo: src/main/bin/sql/template/render.pyc"
    outputs.upToDateWhen { false }  // prevent "Task has not declared any outputs despite executing actions"

    // Git command adapted from mark-longair's 2011-02-28 answer at
    // http://stackoverflow.com/questions/5139290/how-to-check-if-theres-nothing-to-be-committed-in-the-current-branch
    // Gradle capture of stdout from benjamin-muschko's 2012-06-19 answer at
    // https://stackoverflow.com/questions/11093223/how-to-use-exec-output-in-gradle
    doLast {
        new ByteArrayOutputStream().withStream { ostr ->
            def ostream = exec {
                executable = 'git'
                args = ['ls-files', '--other', '--exclude-standard', '--directory', '--no-empty-directory']
                    // ignore empty-ish target/classes/
                standardOutput = ostr
            }
            def stdout = ostr.toString().trim()
            if (! stdout.isEmpty())
            {
                println "Untracked files in repo: Commit, move, or .gitignore these:" + System.properties['line.separator'] + stdout
                throw new BuildCancelledException
                    ("Untracked files in repo: Commit, move, or .gitignore")
            }
        }
    }
}

task dist {
    dependsOn distCheckSrcDirty, distSrcTar, distFullTar, distFullZip
    doLast {
        println "Built for distribution in ${project.buildDir.getName()}/${project.distsDirName}:"
        [distSrcTar, distFullTar, distFullZip].each { dtask -> dtask.outputs.files.each { File file ->
            println file.name
    }}}
}

// misc

javadoc {    // generates into build/docs/javadoc/
    source = sourceSets.main.allJava
    classpath = sourceSets.main.runtimeClasspath
    title = 'JSettlers ' + project.version + ' API'
    excludes ['**/fedorahosted/**']
    options.memberLevel = JavadocMemberLevel.PACKAGE
    options.encoding = 'UTF-8'
    options.overview = 'src/main/java/main-overview.html'  // becomes overview-summary.html
    options.addBooleanOption('author', true)
    options.addBooleanOption('breakiterator', true)
    options.addBooleanOption('version', true)
    options.addBooleanOption('splitindex', false)
    if (JavaVersion.current().isJava8Compatible()) {
        // avoid overly-strict JDK 8 doclint;
        // jdk 7 javadoc doesn't recognize this flag
        options.addBooleanOption('Xdoclint:none', true)
    }
    // Unlike v1.x.xx in Ant, don't generate the "-use" page; IDEs can provide up-to-date usage info
}

// extra functional testing

task extraTest(type: Test) {
    testClassesDirs = sourceSets.extraTest.output.classesDirs
    classpath = sourceSets.extraTest.runtimeClasspath
    testLogging.showStandardStreams = true  // make it easy to see System.out, System.err from sometimes-lengthy tests
    reports.junitXml.destination = file("$buildDir/extraTest-results")  // unit tests use buildDir/test-results
    reports.html.destination = file("$buildDir/reports/extraTests")     // unit tests use buildDir/reports/tests
    outputs.upToDateWhen { false }  // never skip running it
}

// run all python extra tests, using PyUnit (unittest module); returns 0 if no failures
task extraTestPython(type: Exec) {
    executable python_command
    workingDir 'src/extraTest/python'
    args '-m', 'unittest', 'discover', '--verbose'  // discover requires python 2.7 or higher
    environment CLASSPATH: tasks.extraTest.classpath.asPath
}

extraTest.dependsOn test
extraTest.finalizedBy extraTestPython  // run java tests first; run python tests even if java fails

// build setup: try to run python3 or python available in PATH
def static findPythonOrPython3() {
    try {
        def cmd = "python3 --version"
        def proc = cmd.execute()
        proc.waitFor()
        if (proc.exitValue() == 0)
            return 'python3'
    } catch(Exception e) {}

    def cmd = "python --version"
    def proc = cmd.execute()
    proc.waitFor()
    if (proc.exitValue() == 0)
        return 'python'
    else
        throw new GradleScriptException("build environment problem: couldn't run python3 nor python")
}

clean {
    // also remove python bytecode files
    delete fileTree("src/test/python").matching{ include "**/*.pyc" }
    delete fileTree("src/extraTest/python").matching{ include "**/*.pyc" }
}

artifacts {
    archives serverJar, fullJar
}


/*
 * This file is part of the JSettlers project.
 *
 * This file Copyright (C) 2017 Ruud Poutsma <rtimon@gmail.com>
 * Portions of this file Copyright (C) 2017,2019-2024 Jeremy D Monin <jeremy@nand.net>
 * Portions of this file Copyright (C) 2019 Colin Werner
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see http://www.gnu.org/licenses/ .
 */