build.gradle

import java.util.regex.Pattern
import net.ltgt.gradle.errorprone.CheckSeverity

buildscript {
  repositories {
    maven { url 'https://consensys.bintray.com/consensys/' }
    jcenter()
  }
}
plugins {
  id 'com.diffplug.gradle.spotless' version '3.16.0'
  id 'net.ltgt.errorprone' version '0.6'
  id 'io.spring.dependency-management' version '1.0.6.RELEASE'
  id 'com.github.hierynomus.license' version '0.15.0'
  id 'com.jfrog.bintray' version '1.8.3'
  id 'org.jetbrains.kotlin.jvm' version '1.3.20'
  id 'org.jetbrains.dokka' version '0.9.17'
}

description = 'A set of libraries and other tools to aid development of blockchain and other decentralized software in Java and other JVM languages'


//////
// Sanity checks

if (!file("${rootDir}/eth-reference-tests/src/test/resources/tests/README.md").exists()) {
  throw new GradleException("eth-reference-tests/src/test/resources/tests/README.md missing: please clone submodules (git submodule update --init --recursive)")
}
if (!file("${rootDir}/eth-reference-tests/src/test/resources/eth2.0-tests/README.md").exists()) {
  throw new GradleException("eth-reference-tests/src/test/resources/eth2.0-tests/README.md missing: please clone submodules (git submodule update --init --recursive)")
}


//////
// Version numbering

def versionNumber = '1.0.0'
def buildVersion = 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'
}


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

defaultTasks 'checkLicenses', 'spotlessCheck', 'jar', 'test', ':javadoc'

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

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


//////
// Gradle script formatting

spotless {
  groovyGradle {
    target '**/*.gradle'
    greclipse().configFile(rootProject.file('gradle/greclipse-gradle-consensys-style.properties'))
    endWithNewline()
  }
}


subprojects {

  //////
  // Source formatting

  apply plugin: 'com.diffplug.gradle.spotless'
  spotless {
    java {
      target project.fileTree(project.projectDir) {
        include '**/*.java'
        exclude '**/generated-src/**/*.*'
      }
      removeUnusedImports()
      licenseHeaderFile rootProject.file('gradle/spotless.license.java')
      eclipse().configFile(rootProject.file('gradle/eclipse-java-consensys-style.xml'))
      importOrder 'net.consensys', 'java', ''
      endWithNewline()
    }
    kotlin {
      licenseHeaderFile rootProject.file('gradle/spotless.license.java')
      ktlint().userData(['indent_size': '2', 'continuation_indent_size' : '2', 'max_line_length': '120'])
      endWithNewline()
    }
  }


  //////
  // Parallel build execution

  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()
  }

  tasks.withType(JavaCompile) {
    options.fork = true
    options.incremental = true
    options.encoding = 'UTF-8'
  }

  task allDependencies(type: DependencyReportTask) {}
}


//////
// Top-level target for deploy (bintrayUpload depends on it)

task deploy() {}

configurations.archives.artifacts.removeAll { PublishArtifact publishArtifact ->
  (publishArtifact.type == 'jar' && publishArtifact.name == 'cava')}


//////
// Project defaults

allprojects {
  apply plugin: 'java-library'
  apply plugin: 'kotlin'
  apply plugin: 'io.spring.dependency-management'
  apply plugin: 'jacoco'
  apply plugin: 'net.ltgt.errorprone'
  apply plugin: 'com.jfrog.bintray'
  apply plugin: 'maven-publish'
  apply plugin: 'org.jetbrains.dokka'
  apply plugin: 'signing'
  apply from: "${rootDir}/dependency-versions.gradle"
  apply from: "${rootDir}/gradle/check-licenses.gradle"

  version = buildVersion

  repositories { jcenter() }


  //////
  // Compiler arguments

  sourceCompatibility = '1.8'
  targetCompatibility = '1.8'

  jacoco { toolVersion = '0.8.2' }

  dependencies {
    errorprone 'com.google.errorprone:error_prone_core'
    if (JavaVersion.current().isJava8()) {
      errorproneJavac("com.google.errorprone:javac")
    }
  }

  tasks.withType(JavaCompile) {
    // Until https://github.com/gradle/gradle/issues/2510 is resolved and
    // something like a `releaseCompability` property is added, we have to add
    // the --release flag explicitly
    if (JavaVersion.current() > JavaVersion.VERSION_1_8) {
      options.compilerArgs.addAll(['--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('FutureReturnValueIgnored', CheckSeverity.OFF)
      check('UnnecessaryParentheses', CheckSeverity.OFF)
      disableWarningsInGeneratedCode = true
    }
  }

  tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    kotlinOptions {
      jvmTarget = "1.8"
      allWarningsAsErrors = true
      freeCompilerArgs = [
        '-Xjsr305=strict',
        '-Xjvm-default=enable',
        '-Xuse-experimental=kotlin.Experimental'
      ]
    }
  }


  //////
  // Use JUnit5 for testing

  test { useJUnitPlatform() { includeEngines 'spek', 'junit-jupiter' } }


  //////
  // Documentation

  dokka {
    outputFormat = 'html'
    outputDirectory = "$buildDir/docs/dokka"
    jdkVersion = 8
    includeNonPublic = false
    def relativePath = rootDir.toPath().relativize(projectDir.toPath()).toString()
    linkMapping {
      dir = projectDir.toString()
      url = "https://github.com/consensys/cava/blob/master/$relativePath"
      suffix = "#L"
    }
  }


  //////
  // Artifact locations

  jar {
    destinationDir = file("${rootProject.buildDir}/libs")
  }

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

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

  task dokkaJar(type: Jar, dependsOn: dokka) {
    destinationDir = file("${rootProject.buildDir}/docs")
    classifier = 'dokka'
    from dokka.outputDirectory
  }


  //////
  // Packaging and deployment

  tasks.withType(Jar) {
    if (rootProject == project) {
      baseName = project.name
    } else {
      baseName = rootProject.name + '-' + project.name
    }
    manifest {
      attributes('Implementation-Title': baseName,
      'Implementation-Version': project.version)
    }
  }

  if (project.name != 'eth-reference-tests') {

    artifacts {
      if (project != rootProject) {
        archives jar
        archives sourcesJar
      }
      archives dokkaJar
    }

    signing {
      useGpgCmd()
      sign configurations.archives
    }

    publishing {
      publications {
        MavenDeployment(MavenPublication) { publication ->
          if (project != rootProject) {
            from components.java
            artifact sourcesJar { classifier 'sources' }
          }
          artifact dokkaJar { classifier 'javadoc' }
          groupId 'net.consensys.cava'
          artifactId project.jar.baseName
          version project.version

          pom {
            name = project.jar.baseName
            afterEvaluate { description = project.description }
            url = 'https://github.com/ConsenSys/cava'
            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/ConsenSys/cava.git'
              developerConnection = 'scm:git@github.com:ConsenSys/cava.git'
              url = 'https://github.com/ConsenSys/cava'
            }
            developers {
              developer {
                name = 'Chris Leishman'
                email = 'chris@leishman.org'
                organization = 'ConsenSys'
                organizationUrl = 'https://www.consensys.net'
              }
              developer {
                name = 'Antoine Toulme'
                email = 'antoine@lunar-ocean.com'
                organization = 'ConsenSys'
                organizationUrl = 'https://www.consensys.net'
              }
            }
          }
          pom.withXml {
            // use inline versions rather than pom dependency management
            asNode().remove(asNode().dependencyManagement[0])

            def dependenciesNode = asNode().appendNode('dependencies')
            def addDependencyNode = { dep, optional ->
              def dependencyNode = dependenciesNode.appendNode('dependency')
              if (dep instanceof ProjectDependency) {
                dependencyNode.appendNode('groupId', 'net.consensys.cava')
                dependencyNode.appendNode('artifactId', rootProject.name + '-' + dep.name)
                dependencyNode.appendNode('version', dep.version)
              } else {
                dependencyNode.appendNode('groupId', dep.group)
                dependencyNode.appendNode('artifactId', dep.name)
                if (dep.version != null) {
                  dependencyNode.appendNode('version', dep.version)
                } else {
                  def version = dependencyManagement.managedVersions["$dep.group:$dep.name"]
                  dependencyNode.appendNode('version', version)
                }
              }
              if (optional) {
                dependencyNode.appendNode('optional', 'true')
              }

              def ers = dep.excludeRules
              if (!ers.empty) {
                def exclusionsNode = dependencyNode.appendNode('exclusions')
                ers.each { er ->
                  def exclusionNode = exclusionsNode.appendNode('exclusion')
                  exclusionNode.appendNode('groupId', er.group)
                  exclusionNode.appendNode('artifactId', er.module)
                }
              }
            }

            configurations.compile.allDependencies.each { dep ->
              addDependencyNode(dep, false)
            }
            configurations.compileOnly.allDependencies.each { dep ->
              addDependencyNode(dep, true)
            }

            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') {
            // create the signed artifacts
            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'
              }
            }
          }
        }
      }
    }

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

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

    def artifactIdMatcher = Pattern.compile("(.*)-\\d.*")
    bintray {
      user = System.getenv('BINTRAY_USER')
      key = System.getenv('BINTRAY_KEY')
      publications = ['MavenDeployment']
      filesSpec {
        project.extensions.getByType(PublishingExtension).publications.all { publication ->
          publication.getArtifacts().all {
            def ascFile = new File(it.file.getParentFile(), it.file.getName() + '.asc')
            if (ascFile.exists()) {
              def matcher = artifactIdMatcher.matcher(it.file.getName())
              matcher.find()
              def artifactId = matcher.group(1)
              from ascFile.getAbsolutePath()
              into publication.groupId.replaceAll('\\.', '/') + '/' + artifactId + '/' + publication.version + '/'
            }
          }
        }
      }
      dryRun = !(System.getenv('BINTRAY_DEPLOY') == 'true')
      publish = true
      pkg {
        repo = 'consensys'
        name = 'cava'
        userOrg = 'consensys'
        licenses = ['Apache-2.0']
        version {
          name = project.version
          desc = 'Cava distribution'
          released = new Date()
          vcsTag = project.version
        }
      }
    }
    deploy.dependsOn bintrayUpload
  }
}


//////
// Configure root project as a virtual package that depends on all components

dependencies {
  subprojects.each { p ->
    switch (p.name) {
      case 'eth-reference-tests':
      // ignore
        break
      case 'crypto':
        compile(p) {
          exclude group: 'com.github.jnr', module: 'jnr-ffi'
        }
        break
      default:
        compile p
        break
    }
  }
}

jar { enabled = false }

javadoc {
  subprojects.each {
    source += it.javadoc.source
    classpath += it.javadoc.classpath
  }
}

dokka {
  moduleName = rootProject.name
  subprojects.each {
    dependsOn it.classes
    it.sourceSets.main.output.each { d ->
      if (d.exists()) {
        classpath += d
      }
    }
  }
  sourceDirs = files(subprojects.collect {
    return [
      new File(it.projectDir, '/src/main/kotlin'),
      new File(it.projectDir, '/src/main/java')
    ]
  })
  linkMapping {
    dir = rootDir.toString()
    url = "https://github.com/consensys/cava/blob/master"
    suffix = "#L"
  }

  includes = ['PACKAGES.md']

  externalDocumentationLink {
    url = new URL("https://docs.oracle.com/javase/8/docs/api/")
  }

  externalDocumentationLink {
    url = new URL('https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/')
  }
}

dokkaJar {
  baseName = rootProject.name
  manifest {
    attributes('Implementation-Title': baseName,
    'Implementation-Version': project.version)
  }
}