build.gradle

/*
 * PCGen build using the Gradle tool. This file specifies the core build tasks
 * and refers to other files in the code/gradle directory for additional tasks
 * for specific output.
 *
 * Developer build: gradle
 * Incremental dev build: gradle build
 * Full build: gradle all
 * Build and run all tests: gradle clean build slowtest
 * Run the data tests: gradle datatest
 * Run the character integration tests: gradle inttest
 */

// import Ant helper static values to differ system families
import org.apache.tools.ant.filters.FixCrLfFilter

plugins {
    id 'eclipse'
    id 'application'
    id 'build-dashboard'
    id 'checkstyle'
    id "com.github.spotbugs" version '4.4.4'
    id 'java'
    id 'maven-publish'
    id 'pmd'
    id 'idea'
    id "de.undercouch.download" version '4.1.1'
    id 'edu.sc.seis.launch4j' version '2.4.6'
    id 'com.github.ben-manes.versions' version '0.29.0'
    id "com.dorongold.task-tree" version '1.5'
    id "edu.sc.seis.macAppBundle" version "2.3.0"
    id 'org.openjfx.javafxplugin' version '0.0.9'
    id 'org.beryx.runtime' version '1.11.2'
}

javafx {
    version = "14.0.1"
    modules = [ 'javafx.controls', 'javafx.web', 'javafx.swing', 'javafx.fxml', 'javafx.graphics' ]
}

group = 'net.sourceforge.pcgen'

description = """PCGen"""

defaultTasks 'build'

sourceCompatibility = "1.11"
targetCompatibility = "1.11"

ext {
    binDir = "code/bin"
    //Folder where the build stuff is placed.
    outputDir = "$projectDir/output"
    //Installer is placed here
    releaseDir = "${buildDir}/release"
}

//The gradle plugin for netbeans sets the 'mainClass' property instead of 'mainClassName'
//if other IDEs set different properties when trying to execute a given class
//feel free to add them here.
mainClassName = project.hasProperty('mainClass') ? mainClass : 'pcgen.system.Main';

applicationDistribution.from('plugins') {
    into "plugins"
}
applicationDistribution.from('docs') {
    into "docs"
}
applicationDistribution.from('data') {
    into "data"
}
applicationDistribution.from('outputsheets') {
    into "outputsheets"
}
applicationDistribution.from('system') {
    into "system"
}
applicationDistribution.from('preview') {
    into "preview"
}

repositories {
    mavenCentral()
    ivy {
        url "http://pcgen.sourceforge.net/mvnrepo"
        allowInsecureProtocol = true
        patternLayout {
            artifact "[organisation]/jars/[artifact]-[revision].[ext]"
        }
    }
    ivy {
        name "fileRepo"
        url 'http://pc-gen.org/librepo/'
        allowInsecureProtocol = true
    }
    maven {
        url "https://repository.jboss.org/nexus/content/repositories/thirdparty-releases/"
    }
    jcenter()
}

sourceSets {
    main {
        java {
            srcDirs 'code/src/java'
        }
        resources {
            srcDirs = ['code/src/resources']
        }
    }
    test {
        java {
            srcDirs = ['code/src/utest', 'code/src/testcommon']
        }
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources {
            srcDirs = ['code/src/testResources']
        }

    }
    itest {
        java {
            srcDirs = ['code/src/itest', 'code/src/testcommon']
        }
        resources {
            srcDirs = ['code/src/testResources']
        }
        compileClasspath += sourceSets.test.compileClasspath
        runtimeClasspath += sourceSets.test.runtimeClasspath

    }
    slowtest {
        java {
            srcDirs = ['code/src/test', 'code/src/testcommon']
        }
        resources {
            srcDirs = ['code/src/testResources']
        }
        compileClasspath += sourceSets.test.compileClasspath
        runtimeClasspath += sourceSets.test.runtimeClasspath

    }
}

/* Copy 'master' outputsheets into different genre folders */
task copyMasterSheets(type: Copy) {
    outputs.upToDateWhen { false }

    include 'eqsheet_fantasy_std.htm'
    include 'psheet_fantasy_std.htm'
    from 'outputsheets/d20/fantasy/htmlxml'
    into 'outputsheets/d20/historical/htmlxml'

    into ('../../horror/htmlxml') {
        from 'outputsheets/d20/fantasy/htmlxml'
    }
    into ('../../sciencefiction/htmlxml') {
        from 'outputsheets/d20/fantasy/htmlxml'
    }
    into ('../../western/htmlxml') {
        from 'outputsheets/d20/fantasy/htmlxml'
    }
}

compileJava {
    it.dependsOn 'copyMasterSheets'
}

/*
* For information on the exclude group items in this section, and why these are necessary to have Eclipse properly compile PCGen, please see the following items:
* https://bugs.openjdk.java.net/browse/JDK-8215739
* https://bugs.eclipse.org/bugs/show_bug.cgi?id=536928
* https://stackoverflow.com/questions/51094274/eclipse-cant-find-xml-related-classes-after-switching-build-path-to-jdk-10/53824670#53824670
* https://docs.gradle.org/current/userguide/dependency_downgrade_and_exclude.html
*/
dependencies {
    implementation group: 'commons-io', name: 'commons-io', version:'2.7'

    implementation group: 'org.springframework', name: 'spring-web', version:'5.2.7.RELEASE'
    implementation group: 'org.springframework', name: 'spring-beans', version:'5.2.8.RELEASE'
    implementation group: 'org.springframework', name: 'spring-core', version:'5.2.7.RELEASE'
    implementation group: 'org.apache.commons', name: 'commons-lang3', version:'3.11'
    compile('org.apache.xmlgraphics:fop:2.5')
    {
        exclude group: 'xml-apis', module: 'xml-apis'
    }
    implementation group: 'org.apache.commons', name: 'commons-collections4', version: '4.4'
    implementation group: 'org.scijava', name: 'jep', version:'2.4.2'
    implementation group: 'org.freemarker', name: 'freemarker', version:'2.3.30'
    implementation group: 'org.jdom', name: 'jdom2', version:'2.0.6'
    implementation('xalan:xalan:2.7.2')
    {
        exclude group: 'xml-apis', module: 'xml-apis'
    }
    implementation group: 'net.sourceforge.argparse4j', name: 'argparse4j', version: '0.8.1'
    implementation group: 'org.xmlunit', name: 'xmlunit-core', version:'2.7.0'
    implementation group: 'org.controlsfx', name: 'controlsfx', version:'11.0.2'

    implementation group: 'net.sourceforge.pcgen', name: 'PCGen-base', version:'1.0.170'
    implementation group: 'net.sourceforge.pcgen', name: 'PCGen-Formula', version:'1.0.200'

    compileOnly group: 'org.jetbrains', name: 'annotations', version:'19.0.0'
    compileOnly group: 'com.yuvimasory', name: 'orange-extensions', version: '1.3.0'
    compileOnly group: 'com.github.spotbugs', name: 'spotbugs-annotations', version: '3.1.12'

    testImplementation group: 'org.junit.platform', name: 'junit-platform-runner', version: '1.6.2'
    testImplementation group: 'org.junit.platform', name: 'junit-platform-launcher', version: '1.6.2'
    testImplementation group: 'org.junit.jupiter', name:  'junit-jupiter-api', version: '5.6.2'
    testImplementation group: 'org.junit.jupiter', name:  'junit-jupiter-params', version: '5.6.2'
    testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.6.2'
    testImplementation group: 'org.hamcrest', name: 'hamcrest', version: '2.2'
    testImplementation group: 'org.testfx', name: 'testfx-junit5', version: '4.0.16-alpha'
    testImplementation group: 'org.testfx', name: 'openjfx-monocle', version: 'jdk-12.0.1+2'


    testImplementation group: 'org.xmlunit', name: 'xmlunit-matchers', version:'2.7.0'
}

ant.importBuild 'build-gradle.xml'
ant.properties['src.java.dir']="code/src/java"
ant.properties['build.classes.dir']="build/classes/java/main"

configure('jar-all-plugins') {
    group = BasePlugin.BUILD_GROUP // Or use 'build'
    description = 'Create the plugin jars'
}

ext {
    classpath = ""
    configurations.runtimeClasspath.each { lib -> classpath += " libs/${lib.name} "}
}

jar {
    it.dependsOn 'jar-all-plugins'
    manifest {
        attributes 'Implementation-Title': 'PCGen', 'Implementation-Version': archiveVersion,
                'Main-Class': 'pcgen.system.Main', 'Class-Path': classpath
    }
    from {
        configurations.runtimeClasspath.collect { it.directory ? it : zipTree(it) }
    }
}

runtime {
    options = ['--compress', '2']
    modules = [
    'jdk.httpserver',
    'java.rmi',
    'java.desktop',
    'java.xml',
    'java.sql',
    'jdk.unsupported',
    'java.prefs',
    'java.logging',
    'java.naming',
    'jdk.xml.dom',
    'jdk.unsupported.desktop',
    'java.datatransfer',
    'java.scripting',
    'jdk.jfr',
    'jdk.jsobject',
    ]
}

task converterJar(type: Jar, dependsOn: jar) {
    manifest {
        attributes 'Implementation-Title': 'PCGen Data Converter', 'Implementation-Version': archiveVersion,
                'Main-Class': 'pcgen.gui2.converter.PCGenDataConvert', 'Class-Path': 'pcgen.jar' + classpath
    }

    archiveClassifier.set('batch-convert')
    from {
        configurations.runtimeClasspath.collect { it.directory ? it : zipTree(it) }
    }

    from sourceSets.main.output
    include 'none'
}

artifacts {
    archives converterJar
}

task copyToLibs(type: Copy) {
    into "$buildDir/libs"
    from configurations.runtime
}

task copyToOutput(type: Copy, dependsOn: [createExe, copyToLibs, jar,
                                          converterJar]) {
    from "$buildDir/libs/pcgen-${version}.jar"
    from "$buildDir/libs/pcgen-${version}-batch-convert.jar"
    from "$buildDir/launch4j/pcgen.exe"
    from "$projectDir/code/pcgen.bat"
    from("$projectDir/code/pcgen.sh") {
        filter(FixCrLfFilter, eol:FixCrLfFilter.CrLf.newInstance("lf"))
        fileMode 0755
    }
    into outputDir

    rename "(.+)-$version(.+)", '$1$2'
}

task qbuild(type: Copy, dependsOn: [copyToOutput, jar]) {
    description="Copy the executable file into 'output' to create a working environment"
    from "$buildDir/libs/pcgen-${version}.jar"

    into outputDir

    rename "(.+)-$version(.+)", '$1$2'
    mustRunAfter clean
}


task cleanOutput(type: Delete) {
    description="Clean up things copied to the output folder by the build"
    delete outputDir
}

// Alias tasks
tasks.register("buildonly") {
    dependsOn 'copyToOutput'
}

tasks.register("quickbuild") {
    dependsOn 'copyToOutput', 'test'
}

build {
    it.dependsOn 'copyToOutput'
}

clean {
    it.dependsOn 'clean-plugins'
    it.dependsOn 'cleanOutput'
}

//Ensures that clean is never run after build and when clean is called it is run before build so it doesn't delete the new build folder.
build.mustRunAfter clean

test {
    exclude 'pcgen/testsupport/**'
    useJUnitPlatform()
}

task itest(type: Test, dependsOn: [jar]) {
    useJUnitPlatform()
    testClassesDirs = sourceSets.itest.output.classesDirs
    classpath = sourceSets.itest.runtimeClasspath
    systemProperties['jar.path'] = jar.getArchiveFile().get().getAsFile()
}

task slowtest(type: Test, dependsOn: ['jar', 'itest']) {
    useJUnitPlatform()
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    systemProperties['jar.path'] = jar.getArchiveFile().get().getAsFile()
    forkEvery = 1
    // Exclude the two suites to avoid duplicate test runs.
    exclude 'AllJUnitTests.class'
    exclude 'pcgen/core/AllJUnitTests.class'
}

task datatest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    include 'pcgen/persistence/lst/DataTest.class'
    include 'pcgen/persistence/lst/DataLoadTest.class'
}

task inttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/**/*Test.class'
}

task sfinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_starfinder/*Test.class'
}

task pfinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_pathfinder/*Test.class'
}

task rsrdinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_35e/*Test.class'
}

task srdinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_3e/*Test.class'
}

task msrdinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_modern/*Test.class'
}

// Do the lot!
task all(dependsOn: ['build', 'slowtest', 'javadoc', 'buildNsis', 'allReports']) {
}

allprojects {
    tasks.withType(Javadoc) {
        options.addBooleanOption('Xdoclint:none', true)
    }
    tasks.withType(Test) {
        maxHeapSize = "512m"
        maxParallelForks = 1
        enableAssertions = true
        testLogging {
            exceptionFormat = 'full'
            events 'failed', 'skipped'
        }
        jvmArgs += [
                '-Djava.awt.headless=true',
                '-Dtestfx.robot=glass',
                '-Dtestfx.headless=true',
                '-Dprism.order=sw',
                '-Dprism.verbose=true',
                '-Djavafx.macosx.embedded=true',
        ]
    }
}

dependencyUpdates {
    revision='release'
}
dependencyUpdates.resolutionStrategy {
    componentSelection { rules ->
        rules.all { ComponentSelection selection ->
            if (['atlassian'].any { qualifier ->
                    selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
                }) {
                selection.reject('unofficial release')
            }
            boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'preview', 'b', 'ea'].any { qualifier ->
                selection.candidate.version ==~ /(?i).*[.-]$qualifier[.\d-+]*/
            }
            if (rejected) {
                selection.reject('Release candidate')
            }
            if (selection.candidate.version == '2.0.2' && selection.candidate.name == 'xml-apis') {
                selection.reject('older than current')
            }
            if (selection.candidate.version == '2.24' && selection.candidate.name == 'jep') {
                selection.reject('older than current')
            }
            if (selection.candidate.version == '1.8.0_20' && selection.candidate.name == 'openjfx-monocle') {
                selection.reject('older than current')
            }

        }
    }
}

idea {
    module {
        testSourceDirs += project.sourceSets.itest.java.srcDirs
        testSourceDirs += project.sourceSets.slowtest.java.srcDirs
        testSourceDirs += project.sourceSets.test.java.srcDirs
    }
}

wrapper {
    distributionType = Wrapper.DistributionType.ALL
}

run {
    enableAssertions = true
}

apply from: 'code/gradle/autobuild.gradle'
apply from: 'code/gradle/distribution.gradle'
apply from: 'code/gradle/reporting.gradle'
apply from: 'code/gradle/release.gradle'