build.gradle

import com.install4j.gradle.Install4jTask
import de.undercouch.gradle.tasks.download.Download
import groovy.json.JsonSlurper
import groovyx.net.http.ContentType
import groovyx.net.http.HTTPBuilder
import groovyx.net.http.Method
import groovyx.net.http.ParserRegistry
import org.gradle.internal.os.OperatingSystem

buildscript {
  repositories {
    mavenCentral()
    maven { url 'https://maven.ej-technologies.com/repository' }
    maven { url 'https://repo.spring.io/plugins-release' }
  }

  dependencies {
    classpath("gradle.plugin.install4j.install4j:gradle_plugin:7.0.7")
    classpath("org.springframework.build.gradle:propdeps-plugin:${propdepsVersion}")
    classpath "org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}"
    classpath("org.kt3k.gradle.plugin:coveralls-gradle-plugin:${coverallsGradlePluginVersion}")
  }
}

plugins {
  id "com.install4j.gradle" version "7.0.7"
  id "co.riiid.gradle" version "0.4.2"
  id "de.undercouch.download" version "3.4.3"
  id "io.franzbecker.gradle-lombok" version "1.14"
  id 'net.ltgt.apt' version '0.19'
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'propdeps'
apply plugin: 'jacoco'
apply plugin: 'com.github.kt3k.coveralls'
apply plugin: 'distribution'


sourceCompatibility = JavaVersion.VERSION_1_10
targetCompatibility = JavaVersion.VERSION_1_10

// 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"
}

lombok {
  version = "${lombokVersion}"
  sha256 = ""
}

class HttpBuilder extends HTTPBuilder {

  HttpBuilder(String url) {
    super(url)
    this.parser.'text/json' = { resp ->
      def bufferedText = resp.entity.content.getText(ParserRegistry.getCharset(resp)).trim()
      return new JsonSlurper().parseText(bufferedText)
    }
    this.parser.'application/json' = this.parser.'text/json'
  }
}

def httpRequest(Method method, String url, onSuccess) {
  def http = new HttpBuilder(url)

  http.request(method) {
    requestContentType = ContentType.JSON

    headers.'User-Agent' = 'downlords-faf-client-gradle'
    headers.'Authorization' = "token ${project.github.token}"
    headers.'Accept' = 'application/vnd.github.v3+json'

    response.success = onSuccess

    response.failure = { resp, json ->
      logger.debug 'Response headers: \n' + resp.headers.collect { "< $it" }.join('\n')
      def errorMessage = json ? json.message : resp.statusLine
      def ref = json ? "See $json.documentation_url" : ''
      def errorDetails = json && json.errors ? "Details: " + json.errors.collect { it }.join('\n') : ''
      throw new GradleScriptException("$errorMessage. $ref. $errorDetails", null)
    }
  }
}

jacocoTestReport {
  reports {
    xml.enabled = true
  }
}

test {
  testLogging {
    showStandardStreams = true
  }
}

configurations {
  codacy
}


bootRun {
    main = "com.faforever.client.Main"
}

jar {
  manifest {
    attributes "Main-Class": "com.faforever.client.Main",
        "Implementation-Title": "Downlord's FAF Client",
        "Implementation-Version": version,
        "Implementation-Vendor": "Downlord"
  }
}

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

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

task buildInstall4jMediaFiles(type: Install4jTask) {
  group "distribution"
  description 'Creates install4j media files'
  dependsOn 'installDist'

  projectFile = file('downlords-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
  }

  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')
    }
  }
}

task downloadIceAdapter(type: Download) {
  group "native dependencies"
  src "https://github.com/FAForever/java-ice-adapter/releases/download/v${faf_ice_adapter_version}/faf-ice-adapter.jar"
  dest file("${buildDir}/resources/native/faf-ice-adapter.jar")
  onlyIfNewer true
}

task downloadUnixUid(type: Download) {
  group "native dependencies"
  src "https://github.com/FAForever/uid/releases/download/v${faf_uid_version}/faf-uid"
  dest file("${buildDir}/resources/native/faf-uid")
  onlyIfNewer true
  doLast {
    file("${buildDir}/resources/native/faf-uid").setExecutable(true, false)
  }
}

task downloadWindowsUid(type: Download) {
  group "native dependencies"
  src "https://github.com/FAForever/uid/releases/download/v${faf_uid_version}/faf-uid.exe"
  dest file("${buildDir}/resources/native/faf-uid.exe")
  onlyIfNewer true
}

task downloadNativeDependencies(dependsOn: [downloadUnixUid, downloadWindowsUid, downloadIceAdapter]) {
  group "native dependencies"
}

compileJava.dependsOn 'downloadNativeDependencies'
compileJava.dependsOn ':webview-patch:build'

task wrapper(type: Wrapper) {
  gradleVersion = '4.5.1'
}

task sendCoverageToCodacy(type: JavaExec, dependsOn: jacocoTestReport) {
  main = "com.codacy.CodacyCoverageReporter"
  classpath = configurations.codacy
  args = ["-l", "Java", "-r", "${buildDir}/reports/jacoco/test/jacocoTestReport.xml"]
}

repositories {
  mavenCentral()
  jcenter()
  maven { url "https://jitpack.io" }
  maven { url 'https://maven.ej-technologies.com/repository' }
  maven { url "https://dl.bintray.com/typesafe/maven-releases" }
  maven { url "https://maven.teamdev.com/repository/products" }
  maven { url "https://repo.spring.io/milestone/" }
}

jacoco {
  toolVersion = "${jacocoVersion}"
}

dependencies {
  compile("org.springframework.boot:spring-boot-starter")
  compile("org.springframework.boot:spring-boot-starter-cache")
  compile("org.springframework.boot:spring-boot-starter-logging")
  compile("org.springframework.security.oauth.boot:spring-security-oauth2-autoconfigure:${springSecurityOauth2AutoconfigureVersion}")
  compile("org.springframework:spring-web")

  compile("com.github.FAForever:faf-java-commons:${fafCommonsVersion}") {
    exclude module: 'guava'
  }
  compile("com.google.code.gson:gson:2.8.5")
  compile("com.github.micheljung:pircbotx:18481dcbfd") {
    exclude module: 'guava'
  }
  compile("com.google.guava:guava:28.0-jre")
  compile("org.apache.commons:commons-compress:1.18")
  compile("net.java.dev.jna:jna:${jnaVersion}")
  compile("net.java.dev.jna:jna-platform:${jnaVersion}")
  compile("org.eclipse.jgit:org.eclipse.jgit:5.1.3.201810200350-r")
  compile("org.jetbrains:annotations:16.0.3")
  compile("net.sf.jtidy:jtidy:r938")
  compile("com.neovisionaries:nv-i18n:1.23")
  compile("com.rometools:rome:1.11.1")
  compile("org.jsoup:jsoup:1.11.3")
  compile("com.nativelibs4java:bridj:0.7.0")
  compile("com.github.nocatch:nocatch:1.1")
  compile("org.luaj:luaj-jse:3.0.1")
  compile("commons-validator:commons-validator:1.6")
  compile("com.github.micheljung:JJsonRpc:01a7fba5f4")
  compile("javax.inject:javax.inject:1")
  compile("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${jacksonDatatypeJsr310Version}")
  compile("com.github.rutledgepaulv:q-builders:${qBuildersVersion}")
  compile("com.github.nsp:JSkills:${jSkillsVersion}")
  compile("com.github.jasminb:jsonapi-converter:${jsonapiConverterVersion}")
  compile("com.jfoenix:jfoenix:${jfoenixVersion}")
  compile("javax.annotation:javax.annotation-api:1.3.1")
  compile("com.github.ben-manes.caffeine:caffeine")
  compile("org.apache.httpcomponents:httpclient")
  compile("com.github.micheljung:FX-BorderlessScene:3.5.0")

  compile("org.openjfx:javafx-base:${javafxVersion}:${javafxPlatform}")
  compile("org.openjfx:javafx-controls:${javafxVersion}:${javafxPlatform}")
  compile("org.openjfx:javafx-graphics:${javafxVersion}:${javafxPlatform}")
  compile("org.openjfx:javafx-swing:${javafxVersion}:${javafxPlatform}")
  compile("org.openjfx:javafx-fxml:${javafxVersion}:${javafxPlatform}")
  compile("org.openjfx:javafx-web:${javafxVersion}:${javafxPlatform}")
  compile("org.openjfx:javafx-media:${javafxVersion}:${javafxPlatform}")
  compile ("com.github.axel1200:discord-rpc:${discordRpcVersion}")

  compile project(":webview-patch")
  compile("org.javassist:javassist:${project.ext['javassist.version']}")

  provided("com.install4j:install4j-runtime:${install4jRuntimeVersion}")

  testCompile 'junit:junit:4.11'
  testCompile("org.testfx:testfx-core:4.0.8-alpha") {
    exclude module: 'guava'
  }
  testCompile("org.testfx:testfx-junit:4.0.8-alpha")
  testCompile("com.natpryce.hamcrest:hamcrest-reflection:0.1-2")
  testCompile("org.springframework.boot:spring-boot-starter-test")

  optional("org.springframework.boot:spring-boot-configuration-processor")


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