build.gradle

import groovy.xml.XmlParser
import net.ltgt.gradle.errorprone.CheckSeverity
import org.openstreetmap.josm.gradle.plugin.task.GeneratePluginList

import java.nio.file.Files
import java.nio.file.Paths

plugins {
  id "com.diffplug.spotless" version "6.12.0"
  id "com.github.ben-manes.versions" version "0.44.0"
  id "com.github.spotbugs" version "5.0.13"
  // id "de.aaschmid.cpd" version "3.3"
  id "eclipse"
  id "jacoco"
  id "java"
  id "maven-publish"
  id "net.ltgt.errorprone" version "3.0.1"
  id "org.openstreetmap.josm" version "0.8.2"
  id "pmd"
}

archivesBaseName = "openqa"
def gitlabGroup = "gokaart"
def gitlabRepositoryName = "JOSM_OpenQA"

repositories {
  mavenCentral()
  maven {
    url "https://josm.openstreetmap.de/nexus/content/repositories/releases/"
  }
}

def versions = [
  awaitility: "4.2.0",
  // Errorprone 2.11 requires Java 11+
  errorprone: (JavaVersion.toVersion(getJavaVersion()) >= JavaVersion.VERSION_11) ? "2.16.0" : "2.10.0",
  jacoco: "0.8.7",
  jmockit: "1.49.a",
  junit: "5.9.1",
  pmd: "6.20.0",
  spotbugs: "4.7.3",
  wiremock: "2.35.0",
  findsecbugs: "1.12.0",
]

repositories {
  mavenCentral()
}
dependencies {
  spotbugsPlugins "com.h3xstream.findsecbugs:findsecbugs-plugin:${versions.findsecbugs}"
  errorprone("com.google.errorprone:error_prone_core:${versions.errorprone}")

  testImplementation("org.junit.jupiter:junit-jupiter-api:${versions.junit}")
  testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:${versions.junit}")
  testImplementation("org.junit.vintage:junit-vintage-engine:${versions.junit}")
  testImplementation("org.jmockit:jmockit:${versions.jmockit}")
  testImplementation("com.github.spotbugs:spotbugs-annotations:${versions.spotbugs}")
  testImplementation("org.openstreetmap.josm:josm-unittest:"){changing=true}
  testImplementation("com.github.tomakehurst:wiremock-jre8:${versions.wiremock}")
  testImplementation("org.awaitility:awaitility:${versions.awaitility}")
}

int getJavaVersion() {
  // We want to use whatever Java version CI has as default
  def ci = project.hasProperty("isCI") or project.hasProperty("CI") or System.getenv("CI") != null
  // But we want to override if someone set a specific Java version
  def javaVersion = System.getenv("JAVA_VERSION")?.isInteger() ? Integer.valueOf(System.getenv("JAVA_VERSION")) : null
  if (javaVersion != null) {
    return javaVersion
  }
  if (ci) {
    return Integer.valueOf(JavaVersion.current().getMajorVersion())
  }
  return 8
}

logger.lifecycle("Using Java " + getJavaVersion())

java {
  toolchain {
    languageVersion.set(JavaLanguageVersion.of(getJavaVersion()))
  }
}

// Set up Errorprone
tasks.withType(JavaCompile).configureEach {
  options.errorprone {
    error(
      "ClassCanBeStatic",
      "DefaultCharset",
      "ReferenceEquality",
      "WildcardImport"
    )
    warn(
      "ConstantField",
      "FieldCanBeFinal",
      "LambdaFunctionalInterface",
      "MethodCanBeStatic",
      "MultiVariableDeclaration",
      "PrivateConstructorForUtilityClass",
      "RemoveUnusedImports",
      "UngroupedOverloads"
    )
  }
}

test {
  project.afterEvaluate {
    jvmArgs("-javaagent:${classpath.find { it.name.contains("jmockit") }.absolutePath}")
    jvmArgs("-Djunit.jupiter.extensions.autodetection.enabled=true")
    jvmArgs("-Djava.awt.headless=true")
  }
  useJUnitPlatform()
  testLogging.exceptionFormat = 'full'
}

sourceSets {
  test {
    java {
      srcDirs = ["src/test/unit"]
    }
    resources {
      srcDirs = ["src/test/data"]
    }
  }
}
tasks.processResources {
  from("$projectDir/LICENSE")
  from("$projectDir/README.md")
  from("$projectDir/src/resources")
}

spotless {
  java {
    eclipse().configFile "config/josm_formatting.xml"
    endWithNewline()
    importOrder('javax', 'java', 'org', 'com', '')
    indentWithSpaces(4)
    licenseHeader "// License: GPL. For details, see LICENSE file."
    ratchetFrom("origin/master")
    removeUnusedImports()
    trimTrailingWhitespace()
  }
}


josm {
  manifest {
  }
  i18n {
    pathTransformer = getPathTransformer(project.projectDir, "gitlab.com/${gitlabGroup}/${gitlabRepositoryName}/blob")
  }
}

tasks.withType(JavaCompile) {
  options.compilerArgs += [
    "-Xlint:all",
    "-Xlint:-serial",
  ]
}

// Set up JaCoCo
jacoco {
  toolVersion = "${versions.jacoco}"
}
jacocoTestReport {
  dependsOn test
  reports {
    xml.required.set(true)
    html.required.set(true)
  }
}
// TODO uncomment when tests are implemented
// check.dependsOn jacocoTestReport

// Set up PMD
pmd {
  toolVersion = versions.pmd
  ignoreFailures true
  incrementalAnalysis = true
  ruleSets = []
  ruleSetConfig = resources.text.fromFile("$projectDir/config/pmd/ruleset.xml")
  sourceSets = [sourceSets.main]
}

// Set up SpotBugs
spotbugs {
  toolVersion = versions.spotbugs
  ignoreFailures = true
}
spotbugsMain {
  reports {
    xml.required.set(false)
    html.required.set(true)
  }
}
spotbugsTest {
  reports {
    xml.required.set(false)
    html.required.set(true)
  }
}

publishing {
  publications {
    maven(MavenPublication) {
      groupId = "org.openstreetmap.josm.plugins"
      artifactId = archivesBaseName
      version = project.version

      from components.java
    }
  }
}

def ciJobToken = System.getenv("CI_JOB_TOKEN")
def projectId = System.getenv("CI_PROJECT_ID")
if (ciJobToken != null && projectId!= null) {
  publishing.repositories.maven {
    url = "https://gitlab.com/api/v4/projects/$projectId/packages/maven"
    name = "gitlab"
    credentials(HttpHeaderCredentials.class) {
      name = "Job-Token"
      value = ciJobToken
    }
    authentication {
      create("auth", HttpHeaderAuthentication.class)
    }
  }
}