build.gradle

import org.apache.tools.ant.taskdefs.condition.Os

plugins {
  id 'com.github.spotbugs' version '4.7.0' apply false
  id "io.freefair.lombok" version "5.3.0" apply false
  id 'org.owasp.dependencycheck' version '6.1.1' apply false
}

ext {
  interlokCoreVersion = project.hasProperty('interlokCoreVersion') ? project.getProperty('interlokCoreVersion') : '4.0-SNAPSHOT'
  releaseVersion = project.hasProperty('releaseVersion') ? project.getProperty('releaseVersion') : '4.0-SNAPSHOT'
  nexusBaseUrl = project.hasProperty('nexusBaseUrl') ? project.getProperty('nexusBaseUrl') : 'https://nexus.adaptris.net/nexus'
  mavenPublishUrl = project.hasProperty('mavenPublishUrl') ? project.getProperty('mavenPublishUrl') : nexusBaseUrl + '/content/repositories/snapshots'
  javadocsBaseUrl = nexusBaseUrl + "/content/sites/javadocs/com/adaptris"
  repoUsername = project.hasProperty('repoUsername') ? project.getProperty('repoUsername') : 'unknown'
  repoPassword = project.hasProperty('repoPassword') ? project.getProperty('repoPassword') : 'unknown'
  defaultNexusRepo = project.hasProperty('defaultNexusRepo') ? project.getProperty('defaultNexusRepo') : 'https://repo1.maven.org/maven2/'
  offlineJavadocPackageDir = new File(project.buildDir, "offline-javadoc-packages")

  interlokJavadocs= project.hasProperty('interlokJavadocs') ? project.getProperty('interlokJavadocs') : javadocsBaseUrl + "/interlok-core/" + interlokCoreVersion
  interlokCommonJavadocs= project.hasProperty('interlokCommonJavadocs') ? project.getProperty('interlokCommonJavadocs') : javadocsBaseUrl + "/interlok-common/" + interlokCoreVersion
  interlokApacheHttpJavadocs= project.hasProperty('interlokApacheHttpJavadocs') ? project.getProperty('interlokApacheHttpJavadocs') : javadocsBaseUrl + "/interlok-apache-http/" + interlokCoreVersion
  organizationName = "Adaptris Ltd"
  slf4jVersion = '1.7.30'
  junitJupiterVersion = '5.7.1'
  jGroupsVersion = '4.0.16.Final'
}

ext.hasGraphViz = { ->
//  def app = "dot"
//  if (Os.isFamily(Os.FAMILY_WINDOWS)) {
//    app = app + ".exe"
//  }
//  return System.getenv("PATH").split(File.pathSeparator).any{
//    java.nio.file.Paths.get("${it}").resolve(app).toFile().exists()
//  }
  return false
}

if (JavaVersion.current().isJava8Compatible()) {
  allprojects {
    tasks.withType(Javadoc) {
      options.addStringOption('Xdoclint:none', '-quiet')
    }
  }
}
ext.gitBranchNameOrTimestamp = { branchName ->
  if (branchName.equals("HEAD") || branchName.equals("develop") || branchName.startsWith("release")) {
    return new Date().format('HH:mm:ss z');
  }
  return branchName;
}

ext.buildInfo = { ->
   new ByteArrayOutputStream().withStream { os ->
      exec {
        executable = "git"
        args = ["rev-parse", "--abbrev-ref", "HEAD"]
        standardOutput = os
      }
      def branchName = os.toString().replaceAll("\r", "").replaceAll("\n", "").trim();
      return gitBranchNameOrTimestamp(branchName);
    }
}

task clean(type: Delete) {
  delete project.buildDir
}

subprojects {
  apply plugin: 'java'
  apply plugin: 'maven'
  apply plugin: 'maven-publish'
  apply plugin: "jacoco"
  apply plugin: "io.freefair.lombok"
  apply plugin: 'com.github.spotbugs'
  apply plugin: 'org.owasp.dependencycheck'

  sourceCompatibility = JavaVersion.VERSION_11
  targetCompatibility = JavaVersion.VERSION_11
  group   = 'com.adaptris'
  version = releaseVersion
  def versionDir = "$buildDir/version"
  generateLombokConfig.enabled = false

  // In this section you declare where to find the dependencies of your project
  repositories {
    mavenCentral()
    maven { url "$defaultNexusRepo" }
    maven { url "$nexusBaseUrl/content/groups/public" }
    maven { url "$nexusBaseUrl/content/groups/interlok" }
  }

  configurations {
    javadoc {}
    umlDoclet {}
    offlineJavadocPackages {}
    all*.exclude group: 'c3p0'
    all*.exclude group: 'commons-logging'
    all*.exclude group: 'javamail'
    all*.exclude group: 'javax.mail', module: 'mail'
    all*.exclude group: 'org.glassfish.hk2.external'
    all*.exclude group: 'xalan', module: 'xalan'
    all*.exclude group: 'net.sf.saxon', module: 'saxon'
    all*.exclude group: 'org.codehaus.woodstox'
    all*.exclude group: 'org.eclipse.jetty.orbit', module: 'javax.mail.glassfish'
    // INTERLOK-3197 exclude old javax.mail
    all*.exclude group: 'com.sun.mail', module: 'javax.mail'
    all*.exclude group: 'javax.validation', module: 'validation-api'
    all*.exclude group: 'javax.activation', module: 'activation'
    all*.exclude group: 'javax.activation', module: 'javax.activation-api'
  }

  configurations.all {
    resolutionStrategy.cacheChangingModulesFor 300, 'seconds'
  }

  // In this section you declare the dependencies for your production and test code
  dependencies {
    compile ("com.adaptris:interlok-core:$interlokCoreVersion") { changing= true}
    compile ("com.adaptris:interlok-core-apt:$interlokCoreVersion") { changing= true}
    compile ("org.slf4j:slf4j-api:$slf4jVersion")
    compile ("org.slf4j:jcl-over-slf4j:$slf4jVersion")

    annotationProcessor ("com.adaptris:interlok-core-apt:$interlokCoreVersion") { changing= true}

    testCompile ("org.junit.jupiter:junit-jupiter-api:$junitJupiterVersion")
    testCompile ("org.junit.jupiter:junit-jupiter:$junitJupiterVersion")
    testCompile ("org.mockito:mockito-core:3.8.0")
    testCompile ("org.mockito:mockito-inline:3.8.0")
    testCompile ("org.slf4j:slf4j-simple:$slf4jVersion")
    // exclude any log4j dependencies so that we can just use slf4j simple.
    // works around INTERLOk-3233
    testCompile "com.adaptris:interlok-stubs:$interlokCoreVersion", {
      changing= true
      exclude group: "org.apache.logging.log4j"
    }
    testCompile ("org.slf4j:slf4j-log4j12:$slf4jVersion")
    testCompile ("org.slf4j:jcl-over-slf4j:$slf4jVersion")

    javadoc("com.adaptris:interlok-core-apt:$interlokCoreVersion") { changing= true}
    umlDoclet("nl.talsmasoftware:umldoclet:1.1.4")

    offlineJavadocPackages ("com.adaptris:interlok-core:$interlokCoreVersion:javadoc@jar") { changing= true}
    offlineJavadocPackages ("com.adaptris:interlok-common:$interlokCoreVersion:javadoc@jar") { changing= true}

  }

  javadoc {
    onlyIf {
      !hasGraphViz()
    }
    configure(options) {
      options.linksOffline(interlokJavadocs, offlineJavadocPackageDir.getCanonicalPath() + "/interlok-core-$interlokCoreVersion-javadoc.jar")
      options.linksOffline(interlokCommonJavadocs, offlineJavadocPackageDir.getCanonicalPath() + "/interlok-common-$interlokCoreVersion-javadoc.jar")
      taglets = ["com.adaptris.taglet.ConfigTaglet", "com.adaptris.taglet.LicenseTaglet"]
      options.addStringOption "tagletpath", configurations.javadoc.asPath
    }
  }

  test {
    useJUnitPlatform()
  }

  jacocoTestReport {
      reports {
          xml.enabled true
          html.enabled true
      }
  }

  sourceSets {
    main {
      output.dir(versionDir, builtBy: 'generateVersion')
    }
  }

  // Generate the META-INF/adaptris-version file
  task generateVersion {
    doLast {
      def versionFile = new File(new File(versionDir, 'META-INF'), 'adaptris-version')
      versionFile.getParentFile().mkdirs()
      ant.propertyfile(file: versionFile) {
        entry(key: 'component.name', value: componentName)
        entry(key: 'component.description', value: componentDesc)
        entry(key: 'build.version', value: releaseVersion)
        entry(key: 'groupId', value: project.group)
        entry(key: 'artifactId', value: project.name)
        entry(key: 'build.date', value: new Date().format('yyyy-MM-dd'))
        entry(key: 'build.info', value: buildInfo())
      }
    }
  }

  task offlinePackageList(type: Copy) {
    description 'Build an offline package-list for javadocs'
    group 'Documentation'

    project.configurations.offlineJavadocPackages.collect { dependency ->
      from(zipTree(dependency)) {
        into dependency.name
      }
    }
    include "package-list"
    include "element-list"
    into offlineJavadocPackageDir
  }

  task umlJavadoc(type: Javadoc) {
    group 'Documentation'
    description 'Build javadocs using plantuml + graphviz + umldoclet, if dot is available'

    onlyIf {
      hasGraphViz()
    }
    source = sourceSets.main.allJava
    classpath = project.sourceSets.main.compileClasspath
    configure(options) {
      options.linksOffline(interlokJavadocs, offlineJavadocPackageDir.getCanonicalPath() + "/interlok-core-$interlokCoreVersion-javadoc.jar")
      options.linksOffline(interlokCommonJavadocs, offlineJavadocPackageDir.getCanonicalPath() + "/interlok-common-$interlokCoreVersion-javadoc.jar")
      options.linksOffline(interlokApacheHttpJavadocs, offlineJavadocPackageDir.getCanonicalPath() + "/interlok-apache-http-$interlokCoreVersion-javadoc.jar")
      taglets = ["com.adaptris.taglet.ConfigTaglet", "com.adaptris.taglet.LicenseTaglet"]
      options.addStringOption "tagletpath", configurations.javadoc.asPath
      options.addBooleanOption "-no-module-directories", true
      options.docletpath = configurations.umlDoclet.files.asType(List)
      options.doclet = "nl.talsmasoftware.umldoclet.UMLDoclet"
      options.addStringOption "umlBasePath", destinationDir.getCanonicalPath()
      options.addStringOption "umlImageFormat", "SVG"
      options.addStringOption "umlExcludedReferences", "java.lang.Exception,java.lang.Object,java.lang.Enum"
      options.addStringOption "umlIncludePrivateClasses","false"
      options.addStringOption "umlIncludePackagePrivateClasses","false"
      options.addStringOption "umlIncludeProtectedClasses","false"
      options.addStringOption "umlIncludeAbstractSuperclassMethods","false"
      options.addStringOption "umlIncludeConstructors","false"
      options.addStringOption "umlIncludePublicFields","false"
      options.addStringOption "umlIncludePackagePrivateFields","false"
      options.addStringOption "umlIncludeProtectedFields", "false"
      options.addStringOption "umlIncludeDeprecatedClasses", "false"
      options.addStringOption "umlIncludePrivateInnerClasses", "false"
      options.addStringOption "umlIncludePackagePrivateInnerClasses", "false"
      options.addStringOption "umlIncludeProtectedInnerClasses","false"
    }
  }

  spotbugsMain {
    effort = "max"
    reportLevel = "high"
    // showProgress = "true"
    effort = "max"
    // Ignore failures?
    // ignoreFailures = false
    reports {
      xml {
        enabled = false
      }
      html {
        enabled = true
      }
    }
    // includeFilter = new File("$rootDir/gradle/spotbugs-filter.xml")
    // excludeFilter = new File("$rootDir/gradle/spotbugs-exclude.xml")
  }

  // disable spotbugsTests which checks our test code..
  spotbugsTest.enabled = false

  dependencyCheck  {
    suppressionFiles= [ "https://raw.githubusercontent.com/adaptris/interlok/develop/gradle/owasp-exclude.xml" , "$rootDir/gradle/owasp-exclude.xml" ]
    skipConfigurations = [ "antSql", "spotbugs", "umlDoclet", "offlineJavadocPackages", "javadoc", "jacocoAnt", "jacocoAgent", "spotbugsPlugins", "spotbugsSlf4j" ]
    formats = [ "HTML", "JUNIT" ]
    junitFailOnCVSS = 7.0
    failBuildOnCVSS = 7.0
    analyzers {
      assemblyEnabled=false
    }
  }

  task lgtmCompile(type: JavaCompile, dependsOn: delombok) {
    group 'Build'
    description 'Compile for lgtm'

    source = sourceSets.main.extensions.delombokTask
    destinationDir = sourceSets.main.java.outputDir
    classpath = project.sourceSets.main.compileClasspath
  }

  check.dependsOn jacocoTestReport
  javadoc.dependsOn offlinePackageList,umlJavadoc

}