| /* |
| * 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 org.ajoberstar.grgit.Grgit |
| import java.time.Instant |
| import java.time.ZoneId |
| import java.time.format.DateTimeFormatter |
| import java.time.format.FormatStyle |
| import java.util.regex.Pattern |
| import net.ltgt.gradle.errorprone.CheckSeverity |
| |
| buildscript { |
| repositories { jcenter() // jcenter |
| } |
| |
| dependencies { classpath "org.ajoberstar.grgit:grgit-core:3.1.1" } |
| } |
| |
| 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 'org.gradle.crypto.checksum' version '1.1.0' |
| id 'org.jetbrains.kotlin.jvm' version '1.3.20' |
| id 'org.jetbrains.dokka' version '0.9.17' |
| id 'maven-publish' |
| id 'com.jfrog.bintray' version '1.8.3' |
| } |
| |
| 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/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 = '0.10.0' |
| def buildVersion = versionNumber + buildTag() |
| |
| static String buildTag() { |
| if (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 '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() |
| |
| apply from: "${rootDir}/wrapper.gradle" |
| |
| apply from: "${rootDir}/gradle/stage.gradle" |
| |
| ////// |
| // RAT checks |
| |
| if (file('.git').exists()) { |
| apply from: "${rootDir}/gradle/rat.gradle" |
| rat { |
| // Exclude everything under the directory that git should be ignoring via .gitignore or that isn't checked in. These |
| // restrict us only to files that are checked in or are staged. |
| def repo = Grgit.open(currentDir: project.getRootDir()) |
| excludes = { |
| def list = new ArrayList<String>(repo.clean(ignore: false, directories: true, dryRun: true)) |
| // And some of the files that we have checked in should also be excluded from this check |
| list.addAll([ |
| '.*\\.asc', |
| '\\w+/out/.*', |
| 'eth-reference-tests/**', |
| 'build', |
| '.*/build/**', |
| '.editorconfig', |
| '.idea/**', |
| 'gradlew.bat', |
| 'gradlew', |
| 'toml/src/test/resources/**', |
| '.gitattributes', |
| '.*\\.kotlin_module', |
| 'example-v0.4.0.toml', |
| 'hard_example.toml', |
| 'toml-v0.5.0-spec-example.toml', |
| ]) |
| return list |
| } |
| } |
| } |
| |
| ////// |
| // Gradle script formatting |
| |
| spotless { |
| groovyGradle { |
| target '**/*.gradle' |
| greclipse().configFile(rootProject.file('gradle/greclipse-gradle-tuweni-style.properties')) |
| endWithNewline() |
| } |
| } |
| |
| |
| subprojects { |
| |
| ////// |
| // Source formatting |
| |
| apply plugin: 'com.diffplug.gradle.spotless' |
| spotless { |
| java { |
| target project.fileTree(project.projectDir) { |
| include '**/*.java' |
| exclude '**/generated-src/**/*.*' |
| exclude '**/SECP256K1.java' |
| } |
| removeUnusedImports() |
| licenseHeaderFile rootProject.file('gradle/spotless.license.txt') |
| eclipse().configFile(rootProject.file('gradle/eclipse-java-tuweni-style.xml')) |
| importOrder 'org.apache', 'java', '' |
| endWithNewline() |
| } |
| kotlin { |
| licenseHeaderFile rootProject.file('gradle/spotless.license.txt') |
| 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) {} |
| } |
| |
| ////// |
| // Project defaults |
| |
| allprojects { |
| apply plugin: 'java-library' |
| apply plugin: 'kotlin' |
| apply plugin: 'io.spring.dependency-management' |
| apply plugin: 'jacoco' |
| apply plugin: 'com.jfrog.bintray' |
| apply plugin: 'net.ltgt.errorprone' |
| 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(AbstractArchiveTask) { |
| preserveFileTimestamps = false |
| reproducibleFileOrder = true |
| } |
| |
| 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/apache/incubator-tuweni/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) |
| } |
| from(rootProject.projectDir) { |
| include 'DISCLAIMER' |
| include 'LICENSE' |
| include 'NOTICE' |
| into 'META-INF' |
| } |
| } |
| |
| if (project.name != 'eth-reference-tests' && project.name != 'dist') { |
| |
| artifacts { |
| archives sourcesJar |
| archives jar |
| archives dokkaJar |
| } |
| |
| signing { |
| useGpgCmd() |
| sign configurations.archives |
| } |
| |
| publishing { |
| repositories { |
| maven { |
| def isRelease = buildVersion.endsWith('SNAPSHOT') |
| def releasesRepoUrl = "https://repository.apache.org/service/local/staging/deploy/maven2" |
| def snapshotsRepoUrl = "https://repository.apache.org/content/repositories/snapshots" |
| url = isRelease ? snapshotsRepoUrl : releasesRepoUrl |
| |
| def settingsXml = new File(System.getProperty('user.home'), '.m2/settings.xml') |
| |
| def credentialsFound = false; |
| if (settingsXml.exists()) { |
| project.logger.info('Reading .m2/settings.xml') |
| def serverId = (project.properties['distMgmtServerId'] ?: isRelease |
| ? 'apache.releases.https' : 'apache.snapshots.https') |
| def m2SettingCreds = new XmlSlurper().parse(settingsXml).servers.server.find { server -> serverId.equals(server.id.text()) } |
| if (m2SettingCreds) { |
| project.logger.info('Found matching credentials from .m2/settings.xml') |
| credentials { |
| username m2SettingCreds.username.text() |
| password m2SettingCreds.password.text() |
| } |
| credentialsFound = true |
| } |
| } |
| |
| if (!credentialsFound) { |
| project.logger.info('Reading credentials from environment') |
| project.logger.info('Username ' + asfNexusUsername) |
| credentials { |
| username asfNexusUsername |
| password asfNexusPassword |
| } |
| } |
| } |
| } |
| publications { |
| MavenDeployment(MavenPublication) { publication -> |
| if (project != rootProject) { |
| from components.java |
| artifact sourcesJar { classifier 'sources' } |
| } |
| artifact dokkaJar { classifier 'javadoc' } |
| groupId 'org.apache.tuweni' |
| artifactId project.jar.baseName |
| version project.version |
| |
| pom { |
| name = project.jar.baseName |
| afterEvaluate { description = project.description } |
| url = 'https://github.com/apache/incubator-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/apache/incubator-tuweni.git' |
| developerConnection = 'scm:git@github.com:apache/incubator-tuweni.git' |
| url = 'https://github.com/apache/incubator-tuweni' |
| } |
| developers { |
| developer { |
| name = 'Antoine Toulme' |
| email = 'antoine@lunar-ocean.com' |
| organization = 'Apache' |
| organizationUrl = 'https://tuweni.apache.org' |
| } |
| developer { |
| name = 'Jonny Rhea' |
| organization = 'Apache' |
| organizationUrl = 'https://tuweni.apache.org' |
| } |
| developer { |
| name = 'Steven J Schroeder' |
| email = 'sjs@apache.org' |
| organization = 'Apache' |
| organizationUrl = 'https://tuweni.apache.org' |
| } |
| } |
| issueManagement { |
| system = "jira" |
| url = "https://issues.apache.org/jira/projects/TUWENI" |
| } |
| } |
| |
| pom.withXml { |
| // use inline versions rather than pom dependency management |
| asNode().remove(asNode().dependencyManagement[0]) |
| if (asNode().dependencies[0]) { |
| asNode().remove(asNode().dependencies[0]) |
| } |
| |
| def dependenciesNode = asNode().appendNode('dependencies') |
| def addDependencyNode = { dep, optional -> |
| def dependencyNode = dependenciesNode.appendNode('dependency') |
| if (dep instanceof ProjectDependency) { |
| dependencyNode.appendNode('groupId', 'org.apache.tuweni') |
| 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 } |
| } |
| |
| bintray { |
| publications = ['MavenDeployment'] |
| user = project.hasProperty('bintrayUser') ? project.property('bintrayUser') : 'invalid' |
| key = project.hasProperty('bintrayKey') ? project.property('bintrayKey') : 'invalid' |
| pkg { |
| repo = project.hasProperty('bintrayRepo') ? project.property('bintrayRepo') : 'invalid' |
| name = project.hasProperty('bintrayName') ? project.property('bintrayName') : 'invalid' |
| userOrg = project.hasProperty('bintrayOrg') ? project.property('bintrayOrg') : 'invalid' |
| licenses = ['Apache-2.0'] |
| vcsUrl = 'https://github.com/apache/incubator-tuweni.git' |
| } |
| } |
| } |
| } |
| |
| |
| ////// |
| // 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 { |
| subprojects.each { subproject -> |
| if (subproject.name != 'eth-reference-tests') { |
| from subproject.configurations.archives.collect { it.path.endsWith('.jar') }.files.collect { zipTree(it) } |
| } |
| } |
| } |
| |
| 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/apache/incubator-tuweni/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) |
| } |
| } |
