build.gradle

import net.ltgt.gradle.errorprone.CheckSeverity

plugins {
  id 'antlr'
  id 'java-library'
  id 'jacoco'
  id 'maven-publish'
  id 'signing'
  id 'com.diffplug.spotless' version '5.12.5'
  id "com.github.hierynomus.license-report" version "0.16.1"
  id 'io.spring.dependency-management' version '1.0.7.RELEASE'
  id 'net.ltgt.errorprone' version '2.0.1'
}

description = 'A parser for Tom\'s Obvious, Minimal Language (TOML).'

//////
// Version numbering

def versionNumber = '1.1.0'
version = versionNumber + buildTag()

static String buildTag() {
  if (System.getenv('BUILD_RELEASE') == 'true') {
    return ''
  }
  if (System.getenv('CIRCLECI')) {
    def buildNumber = System.getenv('CIRCLE_SHA1').take(4).toUpperCase() +
      String.format('%02X', System.getenv('CIRCLE_BUILD_NUM').toInteger() % 256, 16)
    return '-' + buildNumber + '-snapshot'
  }
  return '-dev'
}

//////
// Dependencies and licensing checks

repositories { mavenCentral() }

apply from: "${rootDir}/gradle/check-licenses.gradle"

//////
// Default tasks and build aliases

defaultTasks 'build', 'checkLicenses', 'javadoc'

def buildAliases = ['dev': [
    'spotlessApply',
    'build',
    'checkLicenses',
    'javadoc'
  ]]

def expandedTaskList = []
gradle.startParameter.taskNames.each {
  expandedTaskList << (buildAliases[it] ? buildAliases[it] : it)
}
gradle.startParameter.taskNames = expandedTaskList.flatten()

//////
// Source formatting

spotless {
  groovyGradle {
    target '**/*.gradle'
    greclipse().configFile(rootProject.file('gradle/greclipse-gradle-style.properties'))
    endWithNewline()
  }
  java {
    target project.fileTree(rootDir) {
      include 'src/**/*.java'
      exclude '**/generated-src/**/*.*'
    }
    removeUnusedImports()
    licenseHeaderFile rootProject.file('gradle/spotless.license.java')
    eclipse().configFile(rootProject.file('gradle/eclipse-java-style.xml'))
    importOrder 'org.tomlj', 'java', ''
    endWithNewline()
  }
}

//////
// Source generation

generateGrammarSource {
  outputDirectory file("${buildDir}/generated-src/antlr/main/org/tomlj/internal")
  arguments << "-visitor" << "-long-messages"
  arguments << "-Xexact-output-dir"
}

configurations {
  compile {
    extendsFrom = extendsFrom.findAll { it != configurations.antlr }
  }
}

//////
// Compilation

sourceCompatibility = '1.8'
targetCompatibility = '1.8'

compileJava.options.encoding = 'UTF-8'
compileTestJava.options.encoding = 'UTF-8'
javadoc.options.encoding = 'UTF-8'

jacoco { toolVersion = '0.8.7' }

tasks.withType(JavaCompile) {
  options.release = 8
  options.compilerArgs += [
    '-Xlint:unchecked',
    '-Xlint:cast',
    '-Xlint:rawtypes',
    '-Xlint:overloads',
    '-Xlint:divzero',
    '-Xlint:finally',
    '-Xlint:static',
    '-Werror'
  ]

  options.errorprone {
    excludedPaths = '.*/generated-src/.*'
    check('UnnecessaryParentheses', CheckSeverity.OFF)
    check('MissingSummary', CheckSeverity.OFF)
    disableWarningsInGeneratedCode = true
  }
}

//////
// Testing

tasks.withType(Test) {
  // If GRADLE_MAX_TEST_FORKS is not set, use half the available processors
  maxParallelForks = (System.getenv('GRADLE_MAX_TEST_FORKS') ?:
    (Runtime.runtime.availableProcessors().intdiv(2) ?: 1)).toInteger()
}

test { useJUnitPlatform() }

task jacocoRootTestReport(type: JacocoReport) {
  reports {
    html.enabled = true
    xml.enabled = true
    csv.enabled = false
  }
  doFirst {
    executionData = files(executionData.findAll { it.exists() })
  }
}

//////
// Documentation

javadoc { exclude '**/internal/**' }

//////
// Dependencies

dependencies {
  errorprone("com.google.errorprone:error_prone_core:2.7.1")

  antlr 'org.antlr:antlr4'

  implementation 'org.antlr:antlr4-runtime'
  compileOnlyApi 'org.checkerframework:checker-qual:3.9.1'

  testImplementation 'org.junit.jupiter:junit-jupiter-api'
  testImplementation 'org.junit.jupiter:junit-jupiter-params'

  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

dependencyManagement {
  dependencies {
    dependencySet(group: 'org.antlr', version: '4.7.2') {
      entry 'antlr4'
      entry 'antlr4-runtime'
    }
    dependencySet(group: 'org.junit.jupiter', version: '5.4.2') {
      entry 'junit-jupiter-api'
      entry 'junit-jupiter-engine'
      entry 'junit-jupiter-params'
    }
  }
}

//////
// Packaging

jar {
  destinationDirectory = file("${rootProject.buildDir}/libs")
  manifest {
    attributes('Implementation-Title': project.name,
    'Implementation-Version': project.version)
  }
}

task sourcesJar(type: Jar, dependsOn: classes) {
  destinationDirectory = file("${rootProject.buildDir}/src")
  archiveClassifier = 'sources'
  from sourceSets.main.allSource
}

task javadocJar(type: Jar, dependsOn: javadoc) {
  destinationDirectory = file("${rootProject.buildDir}/docs")
  archiveClassifier = 'javadoc'
  from javadoc.destinationDir
}

artifacts {
  archives sourcesJar
  archives javadocJar
}

signing {
  useGpgCmd()
  sign configurations.archives
}

task deploy() { }

publishing {
  publications {
    MavenDeployment(MavenPublication) {
      from components.java
      artifact sourcesJar { classifier 'sources' }
      artifact javadocJar { classifier 'javadoc' }
      groupId 'io.github.xtomlj'
      artifactId project.jar.archiveBaseName.get()
      version project.version
      pom {
        name = project.jar.archiveBaseName.get()
        description = project.description
        url = 'https://github.com/xtomlj/xtomlj'
        licenses {
          license {
            name = "The Apache License, Version 2.0"
            url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
          }
        }
        scm {
          connection = 'scm:https://github.com/xtomlj/xtomlj.git'
          developerConnection = 'scm:git@github.com:xtomlj/xtomlj.git'
          url = 'https://github.com/xtomlj/xtomlj'
        }
        developers {
          developer {
            name = 'Chris Leishman'
            email = 'chris@leishman.org'
          }
          developer {
            name = 'Tobias Schmidt'
            email = 'tobias.schmidt24080878@gmail.com'
          }
        }
      }
      pom.withXml {
        if (System.getenv('ENABLE_SIGNING') == 'true') {
          def pomFile = file("${project.buildDir}/generated-pom.xml")
          writeTo(pomFile)
          def pomAscFile = signing.sign(pomFile).signatureFiles[0]
          artifact(pomAscFile) {
            classifier = null
            extension = 'pom.asc'
          }
        }
      }

      if (System.getenv('ENABLE_SIGNING') == 'true') {
        tasks.signArchives.signatureFiles.each {
          artifact(it) {
            def matcher = it.file =~ /-(sources|javadoc)\.jar\.asc$/
            if (matcher.find()) {
              classifier = matcher.group(1)
            } else {
              classifier = null
            }
            extension = 'jar.asc'
          }
        }
      }
    }
  }
  if (System.getenv('MAVEN_CENTRAL_DEPLOY') == 'true') {
    repositories {
      maven {
        credentials {
          username = "$ossrhUsername"
          password = "$ossrhPassword"
        }
        url "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
      }
    }
  }
}

tasks.withType(Sign) {
  onlyIf { System.getenv('ENABLE_SIGNING') == 'true' }
}

model {
  tasks.generatePomFileForMavenDeploymentPublication {
    destination = file("$buildDir/generated-pom.xml")
  }
  tasks.publishMavenDeploymentPublicationToMavenLocal { dependsOn project.tasks.signArchives }
}