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.codearte.nexus-staging' version '0.11.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',
    'gradlew*'
  ]
}

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

  check.dependsOn(editorconfigCheck)
  check.dependsOn(javadoc)

  sourceCompatibility = 1.8
  targetCompatibility = 1.8

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

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

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

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

  task allDeps(type: DependencyReportTask) {}

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

  artifacts {
    archives sourceJar
    archives javadocJar
  }

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

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

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

  signing {
    required {
      scmInfo.isRelease() && gradle.taskGraph.hasTask(tasks.uploadArchives)
    }
    sign configurations.archives
  }

  repositories {
    mavenLocal()
    mavenCentral()
  }

}

gradle.projectsEvaluated {
  subprojects {
    configurations {
      mavenDeploySupport
    }

    dependencies {
      mavenDeploySupport "org.apache.maven.wagon:wagon-http:2.2"
    }

    def mavenProjectDescription = {
      name project.mavenName ?: project.name
      if (project.description) {
        description project.description
      }
      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 {
            role 'architect'
            role 'developer'
          }
        }
        developer {
          id 'cboehme'
          name 'Christoph Böhme'
          email 'c.boehme@dnb.de'
          url 'https://github.com/cboehme'
          roles {
            role 'architect'
            role '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'
      }
    }

    install {
      repositories {
        mavenInstaller {
          pom.project mavenProjectDescription
          beforeDeployment {
            MavenDeployment deployment -> signing.signPom(deployment)
          }
        }
      }
    }

    uploadArchives {
      repositories {
        mavenDeployer {
          configuration = configurations.mavenDeploySupport
          if (project.hasProperty('releaseRepositoryUrl')) {
            repository(url: releaseRepositoryUrl) {
              if (project.hasProperty('releaseRepositoryUser')) {
                authentication(userName: releaseRepositoryUser,
                               password: releaseRepositoryPassword)
              }
            }
          }
          if (project.hasProperty('snapshotRepositoryUrl')) {
            snapshotRepository(url: snapshotRepositoryUrl) {
              if (project.hasProperty('snapshotRepositoryUser')) {
                authentication(userName: snapshotRepositoryUser,
                               password: snapshotRepositoryPassword)
              }
            }
          }
          pom.project mavenProjectDescription
          beforeDeployment {
            MavenDeployment deployment -> signing.signPom(deployment)
          }
        }
      }
    }

   /* task publish {
      dependsOn tasks.uploadArchives
    }*/
/*tasks.withType(PublishToMavenRepository) {
    onlyIf {
        (repository == publishing.repositories.OSSRH &&
            true == scmInfo.isRelease()) ||
        (repository == publishing.repositories.internal)
    }
}
*/
    publishing {
      publications {
        mavenArtifacts(MavenPublication) {
          from components.java
          afterEvaluate {
            groupId = project.group
            artifactId = project.name
          }
        }
      }

      repositories {
        maven {
          name = 'localEmbedded'
          // run generated gradle task `./gradlew
          // publishMavenArtifactsPublicationToLocalEmbeddedRepository`
          // to publish all subprojects into the same local embedded repo:
          url = "file://${rootDir}/build/repo"
        }
        maven {
           name = "OSSRH"
           url = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
           credentials {
             username = System.getenv("MAVEN_USERNAME")
             password = System.getenv("MAVEN_PASSWORD")
           }
        }
        maven {
          name = "GitHubPackages"
          url = "https://maven.pkg.github.com/dr0i/metafacture-core"
          credentials {
            username = System.getenv("GITHUB_ACTOR")
            password = System.getenv("GITHUB_TOKEN")
          }
        }
      }
    }
  }
}

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

nexusStaging {
  if (project.hasProperty('stagingServerUrl')) {
    serverUrl = stagingServerUrl
  }
  if (project.hasProperty('releaseRepositoryUser')) {
    username = releaseRepositoryUser
    password = releaseRepositoryPassword
  }
}

tasks.closeRepository.onlyIf {
  rootProject.scmInfo.isRelease()
}

tasks.releaseRepository.onlyIf {
  rootProject.scmInfo.isRelease()
}

class ScmInfo {
  def version
  def tag

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

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

def getScmInfo() {
  def version = null
  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.equals('HEAD')) {
    logger.lifecycle('Detached HEAD found')
    return "commit-${grgit.head().id}-SNAPSHOT"
  }
  if (grgit.branch.current().name.equals('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"
  }
  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)
}