build.gradle

plugins {
  id 'groovy'
  id 'eclipse'
  id 'idea'
  id 'org.sonarqube' version '2.5'
  id "io.spring.dependency-management" version "1.0.3.RELEASE"
  id "java"
}

description = 'Java client for the RabbitMQ HTTP API'

apply from:   "${rootProject.projectDir}/publish-maven.gradle"

group = 'com.rabbitmq'

repositories {
  mavenCentral()
  maven {
    url 'https://repo.spring.io/libs-milestone'
  }
}

compileJava {
  sourceCompatibility = 1.8
  targetCompatibility = 1.8
}

compileTestJava {
  sourceCompatibility = 1.8
  targetCompatibility = 1.8
}

ext {
  amqpClientVersion='5.8.0'
  commonsHttpClientVersion = '4.5.12'
  okHttpVersion = '3.14.7'
  groovyVersion = '2.4.19'
  jacksonVersion = '2.10.3'
  spockVersion = "1.3-groovy-2.4"
  reactorVersion = "3.3.4.RELEASE"
  reactorNettyVersion = '0.9.6.RELEASE'
  springVersion = '5.2.5.RELEASE'

  linkHomepage = 'https://github.com/rabbitmq/hop'
  linkCi       = 'https://build.spring.io/browse/RMQ'
  linkIssue    = 'https://github.com/rabbitmq/hop/issues'
  linkScmUrl           = 'https://github.com/rabbitmq/hop'
  linkScmConnection    = 'https://github.com/rabbitmq/hop.git'
  linkScmDevConnection = 'git@github.com:rabbitmq/hop.git'

  javadocLinks = ["https://docs.oracle.com/javase/7/docs/api/",
                  "https://docs.oracle.com/javaee/6/api/",
                  "https://www.reactive-streams.org/reactive-streams-1.0.2-javadoc/",
                  "https://projectreactor.io/docs/core/release/api/",
                  "https://fasterxml.github.io/jackson-databind/javadoc/2.9/"] as String[]
}

def httpClients = ['jdk', 'httpclient', 'okhttp']

sourceSets {
  httpClients.each { client ->
    sourceSets.create("${client}DependencyTest") {
      java.srcDirs = ["src/integration-test/${client}/java"]
      compileClasspath += main.output
      runtimeClasspath += main.output
    }
  }
}

dependencyManagement {
  resolutionStrategy {
    cacheChangingModulesFor 0, 'seconds'
  }
  applyMavenExclusions = false
}

dependencies {
  compile ("org.springframework:spring-web:$springVersion", optional)
  compile ("org.apache.httpcomponents:httpclient:$commonsHttpClientVersion", optional)
  compile ("com.squareup.okhttp3:okhttp:$okHttpVersion", optional)
  compile ("com.fasterxml.jackson.core:jackson-databind:$jacksonVersion")
  compile ("io.projectreactor:reactor-core:$reactorVersion", optional)
  compile ("io.projectreactor.netty:reactor-netty:$reactorNettyVersion", optional)

  testCompile "org.codehaus.groovy:groovy-all:$groovyVersion"
  testCompile "org.spockframework:spock-core:$spockVersion"
  testCompile "com.rabbitmq:amqp-client:$amqpClientVersion"

  jdkDependencyTestCompile "junit:junit:4.13"
  jdkDependencyTestCompile "org.springframework:spring-web:$springVersion"
  jdkDependencyTestCompile "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"

  httpclientDependencyTestCompile "junit:junit:4.13"
  httpclientDependencyTestCompile "org.springframework:spring-web:$springVersion"
  httpclientDependencyTestCompile "org.apache.httpcomponents:httpclient:$commonsHttpClientVersion"
  httpclientDependencyTestCompile "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"

  okhttpDependencyTestCompile "junit:junit:4.13"
  okhttpDependencyTestCompile "org.springframework:spring-web:$springVersion"
  okhttpDependencyTestCompile "com.squareup.okhttp3:okhttp:$okHttpVersion"
  okhttpDependencyTestCompile "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"

}

eclipse.project.natures += 'org.springframework.ide.eclipse.core.springnature'

// enable all compiler warnings; individual projects may customize further
[compileJava, compileTestJava, compileTestGroovy]*.options*.compilerArgs = ['-Xlint:all,-options']

test {
  beforeTest { descriptor ->
    logger.lifecycle("Running test \"${descriptor}\"")
  }

  systemProperty 'rabbitmq.management.port', System.getProperty('rabbitmq.management.port') ?: '15672'

  // suppress all console output during testing unless running `gradle -i`
  logging.captureStandardOutput(LogLevel.INFO)
  maxHeapSize = "1024m"
}

httpClients.each { client ->
  tasks.create(name: "${client}DependencyTest", type: Test) {
    testClassesDirs = sourceSets["${client}DependencyTest"].output.classesDirs
    classpath = sourceSets["${client}DependencyTest"].runtimeClasspath
    test.dependsOn name
  }
}

// force test runs even when there are no test changes,
// such test loops are very useful for testing race conditions
// and other concurrency hazards in both Hop and RabbitMQ HTTP API
test.outputs.upToDateWhen { false }

task sourcesJar(type: Jar) {
  archiveClassifier = 'sources'
  from sourceSets.main.allJava
}

task javadocJar(type: Jar) {
  archiveClassifier = 'javadoc'
  from javadoc
}

artifacts {
  archives sourcesJar
  archives javadocJar
}

sonarqube {
  properties {
    property "sonar.jacoco.reportPath", "${buildDir.name}/jacoco.exec"
    property "sonar.links.homepage", linkHomepage
    property "sonar.links.ci", linkCi
    property "sonar.links.issue", linkIssue
    property "sonar.links.scm", linkScmUrl
    property "sonar.links.scm_dev", linkScmDevConnection
    property "sonar.java.coveragePlugin", "jacoco"
  }
}

javadoc {
  group = 'Documentation'
  description = 'Generates the Javadoc API documentation.'
  title = "${rootProject.description} ${version} API"
  options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
  options.author = true
  options.header = rootProject.description
  options.overview = 'src/api/overview.html'
  options.stylesheetFile = file("src/api/stylesheet.css")

  source = sourceSets.main.allJava
  classpath = project.sourceSets.main.compileClasspath
  destinationDir = new File(buildDir, "api")
}

task docsZip(type: Zip) {
  group = 'Distribution'
  archiveClassifier = 'docs'
  description = "Builds -${archiveClassifier} archive containing the api"

  from(javadoc) {
    into 'api'
  }
}

task distZip(type: Zip, dependsOn: docsZip) {
  group = 'Distribution'
  archiveClassifier = 'dist'
  description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
          "suitable for community download page."

  ext.baseDir = "${project.name}-${project.version}";

  from('src/dist') {
    include 'license.txt'
    include 'notice.txt'
    into "${baseDir}"
  }

  from(zipTree(docsZip.archivePath)) {
    into "${baseDir}/docs"
  }

  into("${baseDir}/libs") {
    from project.jar
    from project.sourcesJar
    from project.javadocJar
  }
}

// Create an optional "with dependencies" distribution.
// Not published by default; only for use when building from source.
task depsZip(type: Zip, dependsOn: distZip) { zipTask ->
  group = 'Distribution'
  archiveClassifier = 'dist-with-deps'
  description = "Builds -${archiveClassifier} archive, containing everything " +
          "in the -${distZip.archiveClassifier} archive plus all dependencies."

  from zipTree(distZip.archiveFile)

  gradle.taskGraph.whenReady { taskGraph ->
    if (taskGraph.hasTask(":${zipTask.name}")) {
      def projectName = rootProject.name
      def artifacts = new HashSet()

      rootProject.configurations.runtime.resolvedConfiguration.resolvedArtifacts.each { artifact ->
        def dependency = artifact.moduleVersion.id
        if (!projectName.equals(dependency.name)) {
          artifacts << artifact.file
        }
      }

      zipTask.from(artifacts) {
        into "${distZip.baseDir}/deps"
      }
    }
  }
}

artifacts {
  archives distZip
  archives docsZip
}

task dist(dependsOn: assemble) {
  group = 'Distribution'
  description = 'Builds -dist, -docs and distribution archives.'
}

jar {
  manifest {
    attributes("Automatic-Module-Name": "com.rabbitmq.http.client",
            "Implementation-Version": version)
  }
}