build.gradle

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE
 * file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
 * to You 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 net.ltgt.gradle.errorprone.CheckSeverity
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import java.time.Instant
import java.time.ZoneId
import java.time.format.DateTimeFormatter

buildscript {
  repositories {
    mavenCentral()
  }
}

plugins {
  id 'com.diffplug.spotless' version '6.22.0'
  id 'net.ltgt.errorprone' version '3.1.0'
  id 'org.springframework.boot' version '3.4.0'
  id 'io.spring.dependency-management' version '1.1.3'
  id 'org.gradle.crypto.checksum' version '1.4.0'
  id 'org.jetbrains.kotlin.jvm' version '2.1.0'
  id 'org.jetbrains.kotlin.plugin.spring' version '2.1.0'
  id 'org.jetbrains.dokka' version '1.9.20'
  id 'maven-publish'
  id 'se.patrikerdes.use-latest-versions' version '0.2.18'
  id 'com.github.ben-manes.versions' version '0.49.0'
  id 'org.jreleaser' version '1.16.0'
}

description = 'A set of libraries and other tools to aid development of blockchain and other decentralized software in Java and other JVM languages'
group = "io.consensys.tuweni"

//////
// Version numbering

def versionNumber = '2.7.1-SNAPSHOT'
def buildVersion = versionNumber + buildTag(buildRelease)

static String buildTag(releaseBuild) {
  if (releaseBuild == 'true' || System.getenv('BUILD_RELEASE') == 'true') {
    return ''
  }
  if (System.getenv('BUILD_TIMESTAMP') != null) {
    return DateTimeFormatter.ofPattern("-yyyyMMddHHmmss").withLocale(Locale.US).withZone( ZoneId.systemDefault() ).format(Instant.now())
  }
  return '-SNAPSHOT'
}


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

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

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

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

ext {
  gradleVersion = '8.8'
}

apply from: "${rootDir}/gradle/wrapper.gradle"

apply from: "${rootDir}/gradle/stage.gradle"

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

//////
// Gradle script formatting

spotless {
  groovyGradle {
    target '**/*.gradle'
    endWithNewline()
  }
}

tasks.register('integrationTest', Test) {
}

subprojects {
  //////
  // Source formatting

  apply plugin: 'com.diffplug.spotless'
  spotless {
    java {
      target '**/*.java'
      targetExclude '**/generated-src/**/*.*'
      targetExclude '**/SECP256K1.java'
      removeUnusedImports()
      licenseHeaderFile rootProject.file('gradle/spotless.license.txt')
      googleJavaFormat('1.17.0')
      importOrder 'org.apache', 'java', ''
      trimTrailingWhitespace()
      endWithNewline()
    }
    kotlin {
      licenseHeaderFile rootProject.file('gradle/spotless.license.txt')
      ktlint("0.49.1").editorConfigOverride(['indent_size': '2', 'continuation_indent_size' : '2'])
      trimTrailingWhitespace()
      endWithNewline()
    }
  }

  plugins.withId('java', { _ ->
    sourceSets {
      integrationTest {
        compileClasspath += sourceSets.main.output + sourceSets.test.output
        runtimeClasspath += sourceSets.main.output + sourceSets.test.output
      }
    }

    configurations {
      integrationTestImplementation.extendsFrom testImplementation
      integrationTestRuntime.extendsFrom testRuntime
    }
    dependencies {
      integrationTestRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
      integrationTestRuntimeOnly 'ch.qos.logback:logback-classic'
    }

    tasks.register('integrationTest', Test) {
      description = 'Runs integration tests.'
      group = 'verification'

      testClassesDirs = sourceSets.integrationTest.output.classesDirs
      classpath = sourceSets.integrationTest.runtimeClasspath

      useJUnitPlatform() { 'junit-jupiter' }
      timeout = Duration.ofMinutes(30)
    }

    rootProject.integrationTest.dependsOn integrationTest
  })

  //////
  // Parallel build execution

  tasks.withType(Test).configureEach {
    // 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).configureEach {
    options.fork = true
    options.incremental = true
    options.encoding = 'UTF-8'
  }

  tasks.register('allDependencies', DependencyReportTask) {}
}

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

  bootJar {
    enabled = false
  }

  jar {
    enabled = true
  }

  version = buildVersion

  repositories {
    mavenCentral()
  }

  //////
  // Compiler arguments

  sourceCompatibility = JavaVersion.VERSION_21
  targetCompatibility = JavaVersion.VERSION_21

  dependencies {
    errorprone 'com.google.errorprone:error_prone_core'
  }

  tasks.withType(AbstractArchiveTask).configureEach {
    preserveFileTimestamps = false
    reproducibleFileOrder = true
  }

  tasks.withType(JavaCompile).configureEach {
    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(KotlinCompile).configureEach {
    compilerOptions {
      jvmTarget = JvmTarget.JVM_21
      allWarningsAsErrors = true
      freeCompilerArgs = [
        '-Xjsr305=strict',
        '-Xjvm-default=all'
      ]
    }
  }


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

  test {
    useJUnitPlatform() { 'junit-jupiter' }
    timeout = Duration.ofMinutes(30)
  }

  jacocoTestReport {
    reports {
      xml.required.set(true)
      html.required.set(true)
    }
    getExecutionData().setFrom(fileTree(rootProject.layout.buildDirectory).include("/jacoco/*.exec"))
  }


  //////
  // Artifact locations

  jar {
    destinationDirectory = rootProject.layout.buildDirectory.dir("libs")
  }

  tasks.register('sourcesJar', Jar) {
    dependsOn classes
    destinationDirectory = rootProject.layout.buildDirectory.dir("src")
    archiveClassifier.set('sources')
    from sourceSets.main.allSource
  }

  task javadocJar(type: Jar) {
    dependsOn javadoc
    archiveClassifier.set('javadoc')
    from javadoc.destinationDir
  }

  //////
  // Packaging and deployment

  tasks.withType(Jar).configureEach {
    def moduleName = rootProject.name
    if (rootProject == project) {
      archiveBaseName = project.name
    } else {
      archiveBaseName = rootProject.name + '-' + project.name
      moduleName += ".${project.name}"
    }
    manifest {
      attributes('Implementation-Title': archiveBaseName,
              'Implementation-Version': project.version,
              'Automatic-Module-Name': moduleName.replaceAll("-", "_"))
    }
    from(rootProject.projectDir) {
      include 'DISCLAIMER'
      include 'LICENSE'
      include 'NOTICE'
      into 'META-INF'
    }
  }

  if (project.name != 'dist') {

	artifacts {
      archives sourcesJar
      archives jar
    }

	signing {
      useGpgCmd()
      sign configurations.archives
    }

	publishing {
      repositories {
        maven {
          url = rootProject.layout.buildDirectory.dir("staging-deploy")
        }
      }

      publications {
        create("MavenDeployment", MavenPublication) {
          if (project != rootProject) {
            from components.java
            artifact sourcesJar { archiveClassifier.set('sources') }
            artifact tasks.javadocJar
          }
          
          groupId = 'io.consensys.tuweni'
          artifactId = project == rootProject ? project.name : "${rootProject.name}-${project.name}"
          version = project.version

          pom {
            name = project.name
            afterEvaluate { description = project.description }
            url = 'https://github.com/consensys/tuweni'
            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/tuweni.git'
              developerConnection = 'scm:git@github.com:consensys/tuweni.git'
              url = 'https://github.com/consensys/tuweni'
            }
            developers {
              developer {
                id = "consensys"
                name = 'Protocols Team'
                email = 'devops@consensys.net'
              }
            }
            issueManagement {
              system = "github"
              url = "https://www.github.com/consensys/tuweni/issues"
            }
          
            withXml {
              def root = asNode()
              
              // Remove dependencyManagement section if it exists
              root.dependencyManagement.each { it.parent().remove(it) }
              
              def dependencies = root.dependencies[0] ?: root.appendNode('dependencies')
              dependencies.children().clear()
              
              // Add implementation dependencies with versions from dependency management
              configurations.implementation.allDependencies.each { dep ->
                if (dep.name != 'unspecified') {
                  def node = dependencies.appendNode('dependency')
                  node.appendNode('groupId', dep instanceof ProjectDependency ? "io.consensys.tuweni" : dep.group)
                  node.appendNode('artifactId', dep instanceof ProjectDependency ? "${rootProject.name}-${dep.name}" : dep.name)
                  
                  // Get version from dependency management if available
                  def version = dep.version ?: project.dependencyManagement.managedVersions["${dep.group}:${dep.name}"]
                  node.appendNode('version', version)
                }
              }
              
              // Add compileOnly dependencies as optional without trying to resolve them
              configurations.compileOnly.allDependencies.each { dep ->
                if (dep.name != 'unspecified') {
                  def node = dependencies.appendNode('dependency')
                  node.appendNode('groupId', dep instanceof ProjectDependency ? "io.consensys.tuweni" : dep.group)
                  node.appendNode('artifactId', dep instanceof ProjectDependency ? "${rootProject.name}-${dep.name}" : dep.name)
                  // Get version from dependency management if available
                  def version = dep.version ?: project.dependencyManagement.managedVersions["${dep.group}:${dep.name}"]
                  node.appendNode('version', version)
                  node.appendNode('optional', '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).configureEach {
      onlyIf {
        System.getenv('ENABLE_SIGNING') == 'true'
      }
    }

    tasks.withType(GenerateModuleMetadata).configureEach {
      enabled = false
    }

    // Ensure each project's publication task depends on its own POM generation
    tasks.withType(PublishToMavenLocal).configureEach { publishTask ->
      publishTask.dependsOn(tasks.withType(GenerateMavenPom))
    }
  }
}

//////
// JReleaser at root project level
jreleaser {
  gitRootSearch = true
  release {
    github {
      commitAuthor {
        name = 'Protocols Team'
        email = 'devops@consensys.net'
      }
    }
  }
  signing {
    active = 'ALWAYS'
    armored = true
    verify = true
  }
  deploy {
    maven {
      mavenCentral {
        sonatype {
          active = 'ALWAYS'
          url = 'https://central.sonatype.com/api/v1/publisher'
          stagingRepository('build/staging-deploy')
          // It's taking about 15-20 mins to complete deployment
          retryDelay = 15
          maxRetries = 100
        }
      }
    }
  }
}

// Create a task to prepare the jreleaser directory.
task prepareJreleaserDirectory {
  doLast {
    file(rootProject.layout.buildDirectory.dir("jreleaser")).mkdirs()
  }
}

// Make every task whose name starts with "jreleaser" depend on the preparation task.
tasks.all { t ->
  if (t.name.startsWith("jreleaser")) {
    t.dependsOn prepareJreleaserDirectory
  }
}

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

dependencies {
  subprojects.findAll {
    !it.name.contains('reference-tests')
  }.each { p ->
    switch (p.name) {
      case 'crypto':
        implementation(p) {
          exclude group: 'com.github.jnr', module: 'jnr-ffi'
        }
        break
      default:
        implementation p
        break
    }
  }
}

apply plugin: 'kotlin'
apply plugin: 'org.jetbrains.dokka'

tasks.dokkaHtmlMultiModule.configure {
  outputDirectory = rootProject.layout.buildDirectory.dir("docs")
}

tasks.register("docs") {
  dependsOn dokkaHtmlMultiModule
}

dokkaHtml.configure {
  moduleName = 'tuweni'

  dokkaSourceSets {
    configureEach {

      // Use to include or exclude non public members.
      includeNonPublic.set(false)

      // Do not output deprecated members. Applies globally, can be overridden by packageOptions
      skipDeprecated.set(false)

      // Emit warnings about not documented members. Applies globally, also can be overridden by packageOptions
      reportUndocumented.set(true)

      // Do not create index pages for empty packages
      skipEmptyPackages.set(true)

      // Platform used for code analysis. See the "Platforms" section of this readme
      platform.set(org.jetbrains.dokka.Platform.jvm)

      // List of files with module and package documentation
      // https://kotlinlang.org/docs/reference/kotlin-doc.html#module-and-package-documentation
      includes.from('docs.md')
    }
  }
}

tasks.register('checkNotice') {
  def lines = file("NOTICE").readLines()
  def expected = "Copyright 2024-${LocalDate.now().getYear()} Consensys Software Inc"
  for (line in lines) {
    if (expected == line) {
      return
    }
  }
  throw new GradleException('NOTICE file is not up-to-date')
}