build.gradle

/*
 * Copyright 2017, 2021 Christoph Böhme et al.
 *
 * Licensed under the Apache License, Version 2.0 the "License";
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.regex.Matcher

plugins {
  id 'org.ajoberstar.grgit' version '2.3.0'
  //id 'org.ec4j.editorconfig' version '0.0.3'
  id 'org.sonarqube' version '2.6.2'
  id 'io.github.gradle-nexus.publish-plugin' version '1.3.0'
}

subprojects {
  ext {
    versions = [
      'assertj_core': '3.11.1',
      'commons_compress': '1.21',
      'guava': '32.0.1-jre',
      'jackson_databind': '2.15.1',
      'jdk': '11',
      'junit': '4.12',
      'mockito': '2.27.0',
      'slf4j': '1.7.36',
      'wiremock_jre': '2.35.0'
    ]
  }
}

ext.scmInfo = getScmInfo()

allprojects {
  group = 'org.metafacture'
  version = scmInfo.version
  ext.mavenName = null
}

configure(subprojects.findAll { it.name != 'metafacture-runner' }) {
  apply plugin: 'java-library'
}

project(':metafacture-runner') {
  apply plugin: 'java'
}

//editorconfig {
//  excludes = [
//    '**/*.beacon',
//    '**/*.bgzf',
//    '**/*.bz2',
//    '**/*.bzip2',
//    '**/*.gzip',
//    '**/*.xz',
//    '**/.*',
//    '**/bin',
//    'gradlew*'
//  ]
//}

task editorconfigChecker(type: Exec, group: 'Verification') {
  executable 'misc/bin/editorconfig-checker'
  args('-exclude', '/\\.|/bin/|\\.beacon$|\\.txt\\.|^LICENSE$|^\\.project$|^gradlew.*')
}

subprojects {
  apply plugin: 'signing'
  apply plugin: 'jacoco'
  apply plugin: 'checkstyle'
  apply plugin: 'maven-publish'

  check.dependsOn(editorconfigChecker)
  check.dependsOn(javadoc)

  java {
    toolchain {
      languageVersion = JavaLanguageVersion.of(versions.jdk)
    }
  }

  tasks.withType(JavaExec) {
    javaLauncher = javaToolchains.launcherFor {
      languageVersion = java.toolchain.languageVersion
    }
  }

  tasks.withType(JavaCompile) {
    'all -processing -rawtypes -serial'.split().each {
        options.compilerArgs << "-Xlint:${it}".toString()
    }

    options.compilerArgs << '-Werror'
    options.encoding = 'UTF-8'
  }

  task sourceJar(type: Jar) {
    dependsOn tasks.classes
    from sourceSets.main.allJava
    archiveClassifier = 'sources'
    description 'Creates a jar containing the source files of this project.'
    group 'build'
  }

  task javadocJar(type: Jar) {
    dependsOn tasks.javadoc
    from tasks.javadoc
    archiveClassifier = 'javadoc'
    description 'Creates a jar containing the javadoc of this project.'
    group 'build'
  }

  task allDeps(type: DependencyReportTask) {}

  javadoc {
    options {
      addBooleanOption 'Xwerror', true
    }
  }

  checkstyle {
    toolVersion '8.30'
    checkstyleTest.enabled = false
  }

  test {
    systemProperties['org.slf4j.simpleLogger.defaultLogLevel'] = 'warn'

    testLogging {
      showStandardStreams = true
      exceptionFormat = 'full'
    }
  }

  repositories {
    mavenLocal()
    mavenCentral()
  }

  publishing {
    publications {
      mavenArtifacts(MavenPublication) {
        from components.java

        afterEvaluate {
          groupId = project.group
          artifactId = project.name

          pom {
            name = project.mavenName ?: project.name
            description = project.description ?: project.name
            url = 'https://github.com/metafacture/metafacture-core'
            inceptionYear = '2011'
            developers {
              developer {
                id = 'mgeipel'
                name = 'Markus M. Geipel'
                email = 'm.geipel@dnb.de'
                url = 'https://github.com/mgeipel'
                roles = ['architect', 'developer']
              }
              developer {
                id = 'cboehme'
                name = 'Christoph Böhme'
                email = 'c.boehme@dnb.de'
                url = 'https://github.com/cboehme'
                roles = ['architect', 'developer']
              }
            }
            organization {
              name = 'Metafacture'
              url = 'https://github.com/metafacture'
            }
            licenses {
              license {
                name = 'The Apache License, Version 2.0'
                url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
              }
            }
            mailingLists {
              mailingList {
                name = 'Metafacture Mailing List'
                post = 'metafacture@lists.dnb.de'
                subscribe = 'metafacture-subscribe@lists.dnb.de'
                unsubscribe = 'metafacture-unsubscribe@lists.dnb.de'
                archive = 'http://lists.dnb.de/pipermail/metafacture/'
              }
            }
            scm {
              connection = 'scm:git:https://github.com/metafacture/metafacture-core.git'
              developerConnection = 'scm:git:https://github.com/metafacture/metafacture-core.git'
              url = 'https://github.com/metafacture/metafacture-core'
              tag = rootProject.scmInfo.tag ?: 'HEAD'
            }
            issueManagement {
              system = 'Github'
              url = 'https://github.com/metafacture/metafacture-core/issues'
            }
            ciManagement {
              system = 'Github Actions'
              url = 'https://github.com/metafacture/metafacture-core/actions'
            }
          }
          artifact(sourceJar)
          artifact(javadocJar)
        }
      }
    }
    repositories {
      maven {
        name = "GitHubPackages"
        url = "https://maven.pkg.github.com/metafacture/metafacture-core"
        credentials {
          username = System.getenv("GITHUB_ACTOR")
          password = System.getenv("GITHUB_TOKEN")
        }
      }
      if (scmInfo.isRelease() && project.hasProperty('releaseRepositoryUrl')) {
        maven {
          url = releaseRepositoryUrl
          credentials {
            username = releaseRepositoryUser
            password = releaseRepositoryPassword
          }
        }
      }
    }
  }

  signing {
    required {
      scmInfo.isRelease()
    }
    sign publishing.publications.mavenArtifacts
  }

  task install(dependsOn: publishToMavenLocal,
      description: "Installs the 'archives' artifacts into the local Maven repository. [deprecated]") {
    doFirst { println "This task is deprecated; use 'publishToMavenLocal' instead." }
  }
}

sonarqube {
  properties {
    property 'sonar.exclusions', '**/generated-src/**/*.java'
  }
}

nexusPublishing {
  repositories {
    sonatype ()
  }
}

class ScmInfo {
  def version
  def tag

  ScmInfo(version, tag) {
    this.version = version
    this.tag = tag
  }

  def isRelease() {
    return tag != null
  }
}

def getScmInfo() {
  def tag = getGitTag()
  if (tag != null) {
    logger.lifecycle('SCM tag found. Making a release build')
    version = extractVersionFromTag(tag)
  } else {
    logger.lifecycle('No SCM tag found. Making a snapshot build')
    version = getSnapshotVersion()
  }
  logger.lifecycle("Version is $version")
  return new ScmInfo(version, tag)
}

def getSnapshotVersion() {
  if (grgit == null) {
    logger.warn('No Git repository found')
    return 'non-scm-build-SNAPSHOT'
  }
  if (grgit.branch.current().fullName == 'HEAD') {
    logger.lifecycle('Detached HEAD found')
    return "commit-${grgit.head().id}-SNAPSHOT"
  }
  if (grgit.branch.current().name == 'master') {
    logger.lifecycle('On master branch')
    return 'master-SNAPSHOT'
  }
  if (grgit.branch.current().name.startsWith('releases/')) {
    logger.lifecycle('Release branch found')
    return "${extractVersionFromBranch(grgit.branch.current().name)}-SNAPSHOT"
  }
  if (grgit.branch.current().name.contains('-rc')) {
    logger.lifecycle('Release candidate branch found')
    return "${grgit.branch.current().name}-SNAPSHOT"
  }
  logger.lifecycle('Feature branch found')
  return "feature-${grgit.branch.current().name}-SNAPSHOT"
}

def getGitTag() {
  if (grgit == null) {
    logger.warn('No Git repository found')
    return null
  }
  if (!grgit.status().isClean()) {
    logger.warn('Working copy has modifications. Will not look for tags')
    return null
  }
  def tags = getAnnotatedTags()
  if (tags.isEmpty()) {
    logger.lifecycle('HEAD has no annotated tags')
    return null
  }
  if (tags.size() > 1) {
    logger.warn("HEAD has ${tags.size()} annotated tags")
    return null
  }
  def tag = tags[0]
  logger.lifecycle("Found annotated tag $tag.name")
  return tag.name
}

def getAnnotatedTags() {
  def tags = []
  for (tag in grgit.tag.list()) {
    if (tag.commit == grgit.head()
        && tag.tagger != null
        && tag.dateTime != null) {
      tags.add tag
    }
  }
  return tags
}

def static extractVersionFromTag(tag) {
  Matcher matcher =
      tag =~ /metafacture-core-(\d+\.\d+\.\d+(-[-A-Za-z0-9]+)?)/
  if (!matcher.matches()) {
    throw new GradleException("""\
        Unsupported tag format: $tag
        Could not extract version from tag. Supported tag formats are
            metafacture-core-X.Y.Z and
            metafacture-core-X.Y.Z-QUALIFIER
        """.stripIndent())
  }
  return matcher.group(1)
}

def static extractVersionFromBranch(branch) {
  Matcher matcher =
      branch =~ /releases\/metafacture-core-(\d+\.\d+\.\d+(-[-A-Za-z0-9]+)?)/
  if (!matcher.matches()) {
    throw new GradleException("""\
        Unsupported branch format: $branch
        Could not extract version from branch. Supported branch formats are
            releases/metafacture-core-X.Y.Z and
            releases/metafacture-core-X.Y.Z-QUALIFIER
        """.stripIndent())
  }
  return matcher.group(1)
}