build.gradle

plugins {
    id 'application'
    id "com.diffplug.spotless" version "6.2.0"
    id "org.ajoberstar.grgit" version "5.2.0"
}

rootProject.version = calculatePublishVersion()
def specificVersion = calculateVersion()
def isDevelopBuild = rootProject.version.contains('develop')

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
    maven {
        url "https://artifacts.consensys.net/public/teku/maven/"
    }
    maven {
        url "https://artifacts.consensys.net/public/maven/maven/"
    }

}

dependencies {
    implementation 'info.picocli:picocli:4.6.2'
    annotationProcessor 'info.picocli:picocli-codegen:4.6.2'

    implementation 'org.slf4j:slf4j-api:2.0.7'
    runtimeOnly 'org.slf4j:slf4j-simple:2.0.7'
    runtimeOnly 'org.apache.logging.log4j:log4j-to-slf4j:2.20.0'

    implementation('tech.pegasys.teku.internal:bls:23.3.1') {
        exclude group: 'org.apache.logging.log4j', module: 'log4j-slf4j-impl'
    }
    runtimeOnly 'tech.pegasys:jblst:0.3.8'
    runtimeOnly 'org.bouncycastle:bcprov-jdk15on:1.70'

    implementation 'org.apache.tuweni:tuweni-bytes:2.3.1'
    implementation 'org.apache.tuweni:tuweni-crypto:2.3.1'
    implementation 'org.apache.tuweni:tuweni-ssz:2.3.1'
    implementation 'org.yaml:snakeyaml:2.0'
    implementation 'org.web3j:core:4.8.9'

    // Use JUnit Jupiter API for testing.
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.1'

    // Use JUnit Jupiter Engine for testing.
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

tasks.named('test') {
    // Use junit platform for unit tests.
    useJUnitPlatform()
}

application {
    // Define the main class for the application.
    mainClass = 'web3signer.configuration.generator.App'
}

jar {
  archiveBaseName = rootProject.name
  manifest {
    attributes(
      'Specification-Title': archiveBaseName,
      'Specification-Version': project.version,
      'Implementation-Title': archiveBaseName,
      'Implementation-Version': calculateVersion()
      )
  }
}

distTar {
    compression = Compression.GZIP
    archiveExtension = 'tar.gz'
    archiveFileName = "${project.name}.tar.gz"
}

distZip {
    archiveFileName = "${project.name}.zip"
}

spotless {
    java {
        removeUnusedImports()
        googleJavaFormat()
        trimTrailingWhitespace()
        endWithNewline()
        licenseHeaderFile "${rootDir}/gradle/spotless.java.license"
    }
}

// Calculate the version that this build would be published under (if it is published)
// If this exact commit is tagged, use the tag
// If this is on a release-* branch, use the most recent tag appended with +develop (e.g. 0.1.1-RC1+develop)
// Otherwise, use develop
def calculatePublishVersion() {
  if (!grgit) {
    return 'develop'
  }
  def specificVersion = calculateVersion()
  def isReleaseBranch = grgit.branch.current().name.startsWith('release-')
  if (specificVersion.contains('+')) {
    return isReleaseBranch ? "${specificVersion.substring(0, specificVersion.indexOf('+'))}+develop" : "develop"
  }
  return specificVersion
}

def calculateVersion() {
  if (!grgit) {
    logger.warn("Not building from a git checkout. Version information will not be available. Building from a git checkout is strongly recommended.")
    return 'UNKNOWN+develop'
  }
  String version = grgit.describe(tags: true)
  if (version == null) {
    return "NO_TAG+g${grgit.head().abbreviatedId}"
  }
  def versionPattern = ~/^(?<lastVersion>.*)-(?<devVersion>[0-9]+-g[a-z0-9]+)$/
  def matcher = version =~ versionPattern
  if (matcher.find()) {
    return "${matcher.group("lastVersion")}+${matcher.group("devVersion")}"
  }
  return version
}

task printVersion() {
  doFirst {
    print "Specific version: ${specificVersion}  Publish version: ${project.version}"
  }
}

def getCheckedOutGitCommitHash() {
  def takeFromHash = 8
  grgit ? grgit.head().id.take(takeFromHash) : 'UNKNOWN'
}