source: osm/applications/editors/josm/plugins/wikipedia/build.gradle@ 34181

import java.util.regex.Pattern

plugins {
  id "java"
  id "eclipse"
  id "pmd"
  id "com.github.ben-manes.versions" version "0.17.0"
  id "com.github.spotbugs" version "1.6.1"
  id "net.ltgt.errorprone" version "0.0.13"
  id "org.openstreetmap.josm" version "0.4.0"
}
def versions = [
    errorprone: "2.3.1",
    junit: "5.1.1",
    pmd: "6.2.0",
    spotbugs: "3.1.3"
]

// Set up ErrorProne
dependencies.errorprone "com.google.errorprone:error_prone_core:${versions.errorprone}"
tasks.withType(JavaCompile) {
  options.compilerArgs += [
    '-Xep:DefaultCharset:ERROR',
    '-Xep:ClassCanBeStatic:ERROR',
    '-Xep:StringEquality:ERROR',
    '-Xep:WildcardImport:WARN',
    '-Xep:MethodCanBeStatic:WARN',
    '-Xep:RemoveUnusedImports:WARN',
    '-Xep:PrivateConstructorForUtilityClass:WARN',
    '-Xep:LambdaFunctionalInterface:WARN',
    '-Xep:ConstantField:WARN'
  ]
}

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

spotbugs {
  toolVersion = versions.spotbugs
  ignoreFailures = true
  sourceSets = [sourceSets.main]
}
tasks.withType(com.github.spotbugs.SpotBugsTask) {
  reports {
    xml.enabled = false
    html.enabled = true
  }
}

sourceSets {
  main {
    java {
      srcDirs = ["src"]
    }
    lang {
      srcDirs = ["data"]
    }
    resources {
      srcDirs = ["$projectDir"]
      include "images/**"
      include "GPL-v2.0.txt"
      include "README"
    }
  }
  test {
    java {
      srcDirs = ["test/unit"]
    }
  }
}

repositories {
  jcenter()
}
dependencies {
  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 "com.github.spotbugs:spotbugs-annotations:${versions.spotbugs}"
  testImplementation("org.openstreetmap.josm:josm-unittest:"){changing=true}
}

version = getVersion()
josm {
  josmCompileVersion = "13600"
  manifest {
    // Description is duplicated in build.xml, because only there it is synced to Launchpad for translation
    description = "Simplifies linking OSM objects to Wikipedia articles and Wikidata items"
    oldVersionDownloadLink 12900, "34109", new URL("https://svn.openstreetmap.org/applications/editors/josm/dist/wikipedia.jar?p=34113")
    oldVersionDownloadLink 12878, "33635", new URL("https://svn.openstreetmap.org/applications/editors/josm/dist/wikipedia.jar?p=33636")
  }
}

/**
 * @return the current version of the repo as determined by the first of these commands that returns a valid result:
 *   <ul>
 *     <li>`git log` Search for a line with a git-svn-id in the current commit (append "-dirty" if working tree differs)</li>
 *     <li>`git describe` Let git describe the current commit, should only fail, if this is not a git repo</li>
 *     <li>`svn info` take the revision number from the SVN info command</li>
 *   </ul>
 */
def getVersion() {
  // First attempt: Check if the commit has a git-svn-id, return SVN revision
  def result = getVersion("git-svn-id: .*@([1-9][0-9]*) .*", "git", "log", "-1", "--format=%b")
  if (result == null) {
    // Second attempt: Check if the commit can be git-described, return the description by git
    result = getVersion("(.+)", "git", "describe", "--always", "--long", "--dirty")
    if (result == null) {
      // Third attempt: Check if we are in an SVN repo, return revision number
      result = getVersion("Revision: ([1-9][0-9]*)", "svn", "info")
      if (result == null) {
        result = "UNKNOWN"
      } else {
        result = "r$result"
      }
    }
  } else {
    result = "r$result"
    def dirtyProcess = new ProcessBuilder("git", "diff-index", "--quiet", "HEAD").start()
    if (dirtyProcess.waitFor() != 0) {
      result += "-dirty"
    }
  }
  return result
}

/**
 * Runs the specified command, matches the lines of the output with the given linePattern.
 * @param linePattern the linePattern to match the lines against
 * @param command the command to execute
 * @return if a line matches, return the first RegEx group, else return null
 */
def getVersion(String linePattern, String... command) {
  def process = new ProcessBuilder(command).directory(project.projectDir).start()
  if (process.waitFor() != 0) {
    return null
  }
  def pattern = Pattern.compile(linePattern)
  return Arrays.stream(process.inputStream.text.split("\n"))
    .map { pattern.matcher(it)}
    .filter { it.matches() }
    .map { it.group(1).trim() }
    .findFirst()
    .orElse(null)
}