build.gradle

/*
 * Copyright (c) 2018-2022 VMware Inc. or its affiliates, All Rights Reserved.
 *
 * Licensed 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
 *
 *   https://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.gradle.util.VersionNumber
import java.text.SimpleDateFormat

plugins {
  id "idea"
  alias(libs.plugins.artifactory)
  alias(libs.plugins.bnd) apply false
  alias(libs.plugins.japicmp)
  alias(libs.plugins.download)
  alias(libs.plugins.jcstress) apply false
  alias(libs.plugins.spotless)
}

apply from: 'gradle/releaser.gradle'

description = 'Reactive Object Pool root build'

def osgiVersion(String v) {
  def versionNumber = VersionNumber.parse(v)
  def result
  if (versionNumber.qualifier == null || versionNumber.qualifier.size() == 0) {
    result = "${v}.RELEASE"
    println "$v is a release, will use $result for bnd"
  }
  else if (versionNumber.qualifier.equalsIgnoreCase("SNAPSHOT")) {
    def sdf = new SimpleDateFormat("yyyyMMddHHmm");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    def buildTimestamp = sdf.format(new Date())
    result = "${versionNumber.major}.${versionNumber.minor}.${versionNumber.micro}.BUILD-$buildTimestamp"
    println "$v is a snapshot, will use $result for bnd"
  }
  else {
    result = "${versionNumber.major}.${versionNumber.minor}.${versionNumber.micro}.${versionNumber.qualifier}"
    println "$v is neither release nor snapshot, will use $result for bnd"
  }
  return result
}

ext {
  isCiServer = System.getenv().containsKey("CI") //doesn't detect Bamboo

  jdk = JavaVersion.current().majorVersion
  jdkJavadoc = "https://docs.oracle.com/javase/$jdk/docs/api/"
  if (JavaVersion.current().isJava11Compatible()) {
    jdkJavadoc = "https://docs.oracle.com/en/java/javase/$jdk/docs/api/"
  }
  println "JDK Javadoc link for this build is ${rootProject.jdkJavadoc}"
}

spotless {
  if (project.hasProperty("spotlessFrom")) {
    if (project.spotlessFrom == "ALL") {
      println "[Spotless] Ratchet deactivated"
    }
    else {
      println "[Spotless] Ratchet from $project.spotlessFrom"
      ratchetFrom project.spotlessFrom
    }
  }
  else if (isCiServer) {
    println "[Spotless] CI detected without explicit branch, not enforcing check"
    enforceCheck false
  }
  else {
    String spotlessBranch = "origin/main"
    println "[Spotless] Local run detected, ratchet from $spotlessBranch"
    ratchetFrom spotlessBranch
  }
  java {
    target '**/*.java'
    licenseHeaderFile('codequality/spotless/licenseSlashstarStyle.txt')
  }
}

configure(subprojects) { project ->
  group = 'io.projectreactor.addons'

  apply plugin: 'java-library'
  apply plugin: 'jacoco'
  apply plugin: 'biz.aQute.bnd.builder'
  apply from: "${rootDir}/gradle/doc.gradle"
  apply from: "${rootDir}/gradle/setup.gradle"

  jacocoTestReport {
    reports {
      xml.enabled = true
      html.enabled = true
    }
  }

  [compileJava, compileTestJava]*.options*.compilerArgs = ["-Xlint:varargs",
                                                           "-Xlint:cast",
                                                           "-Xlint:classfile",
                                                           "-Xlint:dep-ann",
                                                           "-Xlint:divzero",
                                                           "-Xlint:empty",
                                                           "-Xlint:finally",
                                                           "-Xlint:overrides",
                                                           "-Xlint:path",
                                                           "-Xlint:processing",
                                                           "-Xlint:static",
                                                           "-Xlint:try",
                                                           "-Xlint:deprecation",
                                                           "-Xlint:unchecked",
                                                           "-Xlint:-serial",      // intentionally disabled
                                                           "-Xlint:-options",     // intentionally disabled
                                                           "-Xlint:-fallthrough", // intentionally disabled
                                                           "-Xlint:rawtypes"
  ]

  compileJava {
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
  }

  compileTestJava {
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
  }

  if (JavaVersion.current().isJava8Compatible()) {
    compileTestJava.options.compilerArgs += "-parameters"
  }

  [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
  sourceSets.test.resources.srcDirs = ["src/test/resources", "src/test/java"]

  project.tasks.withType(Test).all {
    scanForTestClasses = false
    include '**/*Tests.*'
    include '**/*Test.*'
    exclude '**/*Abstract*.*'
  }

  test {
    //configure tag support for the core test task
    def tags = rootProject.findProperty("junit-tags")
    if (tags != null) {
      println "junit5 tags: $tags"
      useJUnitPlatform() {
        includeTags "$tags"
      }
    }
    else {
      useJUnitPlatform()
    }
    testLogging {
      events  "passed", "failed"
      showExceptions true
      exceptionFormat "full"
      showStandardStreams true
    }
  }

  repositories {
    mavenCentral()
    maven { url "https://oss.sonatype.org/content/repositories/releases/" }
    if (version.endsWith('-SNAPSHOT') || version.contains('-SNAPSHOT-')) { //classic or customized snapshots
      maven { url 'https://repo.spring.io/snapshot' }
    }
    maven { url 'https://repo.spring.io/milestone' }
  }
}


configurations.all {
  // check for updates every build
  resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}