build.gradle

import com.install4j.gradle.Install4jTask
import org.gradle.internal.os.OperatingSystem

buildscript {
  repositories {
    mavenCentral()
  }
}

plugins {
  id 'org.springframework.boot' version '3.1.2'
  id "com.install4j.gradle" version "10.0.6"
  id "de.undercouch.download" version "5.4.0"
  id 'jacoco'
  id 'java'
  id 'distribution'
}

apply plugin: 'io.spring.dependency-management'

// source: https://github.com/mendhak/Gradle-Travis-Colored-Output/blob/master/ColoredOutput.gradle
tasks.withType(Test).configureEach {

  String ANSI_BOLD_WHITE = "\u001B[0;1m";
  String ANSI_RESET = "\u001B[0m";
  String ANSI_BLACK = "\u001B[30m";
  String ANSI_RED = "\u001B[31m";
  String ANSI_GREEN = "\u001B[32m";
  String ANSI_YELLOW = "\u001B[33m";
  String ANSI_BLUE = "\u001B[34m";
  String ANSI_PURPLE = "\u001B[35m";
  String ANSI_CYAN = "\u001B[36m";
  String ANSI_WHITE = "\u001B[37m";
  String CHECK_MARK = "\u2713";
  String NEUTRAL_FACE = "\u0CA0_\u0CA0";
  String X_MARK = "\u274C";
  String indent = '\t';

  def outputCache = new HashMap<TestDescriptor, List<String>>()

  beforeTest { TestDescriptor descriptor -> outputCache.put(descriptor, new ArrayList()) }

  onOutput { TestDescriptor descriptor, TestOutputEvent testOutputEvent ->

    def outputLines = outputCache.get(descriptor)
    if (outputLines != null) {
      outputLines.add(testOutputEvent.getMessage())
    }
  }

  afterTest { TestDescriptor descriptor, TestResult result ->
    if (result.failedTestCount > 0) {
      String output = outputCache.remove(descriptor).join(indent)


      def nameParts = descriptor.parent.name.split("\\.")
      def simpleParentName = nameParts[nameParts.length - 1]

      out.println()
      out.println(simpleParentName + " > " + descriptor.name + " STANDARD_OUT")
      out.println(indent + output)
      out.println()
    }
  }

  afterSuite { desc, result ->
    if (!desc.parent) { // will match the outermost suite
      def failStyle = ANSI_RED
      def skipStyle = ANSI_YELLOW
      def summaryStyle = ANSI_WHITE

      switch (result.resultType) {
        case TestResult.ResultType.SUCCESS:
          summaryStyle = ANSI_GREEN;
          break;
        case TestResult.ResultType.FAILURE:
          summaryStyle = ANSI_RED;
          break;
      }

      out.println("--------------------------------------------------------------------------");
      out.println("Results: " + summaryStyle + " ${result.resultType} " + ANSI_RESET
              + " (${result.testCount} tests, "
              + ANSI_GREEN + " ${result.successfulTestCount} passed " + ANSI_RESET
              + ", " + failStyle + " ${result.failedTestCount} failed " + ANSI_RESET
              + ", " + skipStyle + " ${result.skippedTestCount} skipped " + ANSI_RESET
              + ")");
      out.println("--------------------------------------------------------------------------");
    }
  }
}

//Specify jacoco version to work with java17
jacoco {
  toolVersion = "0.8.7"
}

sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17

// These are read from gradle.properties
version "${version}"
project.ext.javafxPlatform = "${javafxPlatform}"

bootJar.enabled = false
jar.enabled = true

if (javafxPlatform == "unspecified") {
  switch (OperatingSystem.current()) {
    case OperatingSystem.LINUX:
      project.ext.javafxPlatform = "linux"
      break
    case OperatingSystem.MAC_OS:
      project.ext.javafxPlatform = "mac"
      break
    case OperatingSystem.WINDOWS:
      project.ext.javafxPlatform = "win"
      break
  }
}
println "Platform is: ${javafxPlatform}"

compileJava.dependsOn(processResources)
processResources {
  filesMatching('**/application.yml') {
    filter {
      it.replace('#faf-client.version#', project.version.toString())
    }
  }
}

configurations {
  compile.exclude module: "assertj-core"
}

jacocoTestReport {
  reports {
    xml.getRequired().set(true)
    html.getRequired().set(false)
  }
}

test {
  useJUnitPlatform()
  systemProperties = [
          'junit.jupiter.execution.parallel.enabled': true
  ]
  testLogging {
    exceptionFormat = 'full'
  }

  maxHeapSize = "1024m"
}

configurations {
  codacy
}

distributions {
  main {
    contents {
      from {
        [
                configurations.runtimeClasspath,
                jar,
                downloadIceAdapter.outputs.files,
                downloadUnixUid.outputs.files,
                downloadWindowsUid.outputs.files
        ]
      }
      exclude('**/i4jruntime*.jar')
    }
  }
}

bootRun {
  mainClass = "com.faforever.client.Main"
    jvmArgs = [
            "-DnativeDir=build/resources/native",
            "-Dprism.forceGPU=true",
            "-Xmx1g",
            "-XX:MinHeapFreeRatio=15",
            "-XX:MaxHeapFreeRatio=33",
            "-XX:+HeapDumpOnOutOfMemoryError",
            "-XX:+UseZGC",
            "-Dio.netty.allocator.type=unpooled",
            "-Djava.net.preferIPv4Stack=true",
            "-XX:TieredStopAtLevel=1",
            // Needed for getting process handle via reflection
            "--add-opens=java.base/java.lang=ALL-UNNAMED",
    ]
}

jar {
  manifest {
    attributes "Main-Class": "com.faforever.client.Main",
        "Implementation-Title": "FAF Client",
        "Implementation-Version": archiveVersion,
        "Implementation-Vendor": "Forged Alliance Forever"
  }
}

install4j {
  if (project.hasProperty('install4jHomeDir')) {
    installDir = file(install4jHomeDir)
  }
  if (project.hasProperty('install4jLicense')) {
    license = install4jLicense
  }
}

tasks.register('buildInstall4jMediaFiles', Install4jTask) {
  group "distribution"
  description 'Creates install4j media files'
  dependsOn 'installDist'

  projectFile = file('faf-client.install4j')
  release = version

  switch (project.ext.javafxPlatform) {
    case "linux":
      mediaTypes = ['unixInstaller', 'unixArchive']
      break
    case "mac":
      mediaTypes = ['macos', 'macosFolder', 'macosArchive', 'macosFolderArchive']
      break
    case "win":
      mediaTypes = ['windows', 'windowsArchive']
      break
  }

  it.doFirst {
    println "Building version ${version}"
    if (!project.hasProperty('install4jHomeDir')) {
      throw new RuntimeException('Specify install4jHomeDir in gradle.properties and set it to an install4j installation directory')
    }
  }
}

tasks.register('downloadIceAdapter', Download) {
  group "native dependencies"
  src "https://github.com/FAForever/java-ice-adapter/releases/download/${iceAdapterVersion}/faf-ice-adapter-${iceAdapterVersion}-nojfx.jar"
  dest file("${buildDir}/resources/native/faf-ice-adapter.jar")
  onlyIfNewer true
}

tasks.register('downloadUnixUid', Download) {
  group "native dependencies"
  src "https://github.com/FAForever/uid/releases/download/v4.0.4/faf-uid"
  dest file("${buildDir}/resources/native/faf-uid")
  onlyIfNewer true
  it.doLast {
    file("${buildDir}/resources/native/faf-uid").setExecutable(true, false)
  }
}

tasks.register('downloadWindowsUid', Download) {
  group "native dependencies"
  src "https://github.com/FAForever/uid/releases/download/v4.0.4/faf-uid.exe"
  dest file("${buildDir}/resources/native/faf-uid.exe")
  onlyIfNewer true
}

tasks.register('downloadNativeDependencies') {
  dependsOn downloadUnixUid, downloadWindowsUid, downloadIceAdapter
  group "native dependencies"
}

compileJava.dependsOn 'downloadNativeDependencies'

tasks.register('sendCoverageToCodacy', JavaExec) {
  dependsOn jacocoTestReport
  mainClass = "com.codacy.CodacyCoverageReporter"
  classpath = configurations.codacy
  args = ["-l", "Java", "-r", "${buildDir}/reports/jacoco/test/jacocoTestReport.xml"]
}

repositories {
  mavenCentral()
  maven { url "https://jitpack.io" }
  maven { url 'https://maven.ej-technologies.com/repository' }
}

dependencies {
  implementation("org.springframework.boot:spring-boot-starter")
  implementation("org.springframework.boot:spring-boot-starter-cache")
  implementation("org.springframework.boot:spring-boot-starter-logging")
  implementation("org.springframework.boot:spring-boot-starter-websocket")
  implementation("org.springframework.boot:spring-boot-starter-webflux")
  implementation("org.springframework.boot:spring-boot-starter-oauth2-client")
  implementation("org.springframework:spring-web")
  implementation("org.springframework:spring-websocket")

  implementation("io.projectreactor.addons:reactor-extra")

  def commonsVersion = "4a3facc824"

  implementation("com.github.FAForever.faf-java-commons:faf-commons-data:${commonsVersion}") {
            exclude module: 'guava'
          }
  implementation("com.github.FAForever.faf-java-commons:faf-commons-api:${commonsVersion}")
  implementation("com.github.FAForever.faf-java-commons:faf-commons-lobby:${commonsVersion}")
  implementation("com.google.guava:guava:32.1.2-jre")
  implementation("org.apache.commons:commons-compress:1.23.0")
  implementation("net.java.dev.jna:jna:5.13.0")
  implementation("net.java.dev.jna:jna-platform:5.13.0")
  implementation("org.eclipse.jgit:org.eclipse.jgit:6.4.0.202211300538-r")
  implementation("org.jetbrains:annotations:24.0.1")
  implementation("com.neovisionaries:nv-i18n:1.29")
  implementation("com.nativelibs4java:bridj:0.7.0")
  implementation("org.luaj:luaj-jse:3.0.1")
  implementation("commons-validator:commons-validator:1.7")
  implementation("com.github.micheljung:JJsonRpc:01a7fba5f4")
  implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")
  implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
  implementation("com.github.rutledgepaulv:q-builders:1.6")
  implementation("com.github.nsp:JSkills:8b333ec63d")
  implementation("com.github.jasminb:jsonapi-converter:0.13")
  implementation("javax.annotation:javax.annotation-api:1.3.2")
  implementation("com.github.ben-manes.caffeine:caffeine")
  implementation("io.github.micheljung:fxstage:0.8.3")
  implementation("io.github.micheljung:jfx-waitomo-theme:0.3.0")
  implementation("org.kitteh.irc:client-lib:8.0.0")
  def mapstructVersion = "1.5.5.Final"
  implementation("org.mapstruct:mapstruct:${mapstructVersion}")
  implementation("com.code-disaster.steamworks4j:steamworks4j:1.9.0")

  def javafxVersion = "20"
  implementation("org.openjfx:javafx-base:${javafxVersion}:${javafxPlatform}")
  implementation("org.openjfx:javafx-controls:${javafxVersion}:${javafxPlatform}")
  implementation("org.openjfx:javafx-graphics:${javafxVersion}:${javafxPlatform}")
  implementation("org.openjfx:javafx-swing:${javafxVersion}:${javafxPlatform}")
  implementation("org.openjfx:javafx-fxml:${javafxVersion}:${javafxPlatform}")
  implementation("org.openjfx:javafx-web:${javafxVersion}:${javafxPlatform}")
  implementation("org.openjfx:javafx-media:${javafxVersion}:${javafxPlatform}")
  implementation("com.github.1-alex98:discord-rpc:1.6.2-jna")
  implementation("org.controlsfx:controlsfx:11.1.2")
  implementation("org.fxmisc.flowless:flowless:0.7.1")
  implementation("de.codecentric.centerdevice:javafxsvg:1.3.0")

  implementation("org.javassist:javassist:3.29.2-GA")

  implementation("com.install4j:install4j-runtime:10.0.6")

  testImplementation("com.squareup.okhttp3:okhttp")
  testImplementation("com.squareup.okhttp3:mockwebserver")
  testImplementation("io.projectreactor:reactor-test")
  testImplementation("org.testfx:testfx-core:4.0.16-alpha") {
    exclude module: 'guava'
  }
  testImplementation("io.projectreactor.netty:reactor-netty")
  testImplementation("org.testfx:testfx-junit5:4.0.16-alpha")
  testImplementation("com.natpryce.hamcrest:hamcrest-reflection:0.1-2")
  testImplementation("org.springframework.boot:spring-boot-starter-test")
  testImplementation("org.testfx:openjfx-monocle:jdk-12.0.1+2")

  annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
  annotationProcessor("org.projectlombok:lombok")
  annotationProcessor("org.mapstruct:mapstruct-processor:${mapstructVersion}")
  testAnnotationProcessor("org.projectlombok:lombok")
  testAnnotationProcessor("org.mapstruct:mapstruct-processor:1.5.5.Final")
  compileOnly("org.projectlombok:lombok")
  testCompileOnly("org.projectlombok:lombok")

  codacy("com.github.codacy:codacy-coverage-reporter:-SNAPSHOT")
}