ratpack.gradle

/*
 * Copyright 2013 the original author or authors.
 *
 * 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
 *
 *    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 groovy.json.JsonSlurper

import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.locks.ReentrantLock

buildscript {
  repositories {
    jcenter()
  }

  dependencies {
    classpath "org.jfrog.buildinfo:build-info-extractor-gradle:2.2.3"

    // Artifactory plugin pulls in very old Guava, which conflicts with child projects.
    // Force to newer version here.
    classpath 'com.google.guava:guava:18.0'

    classpath "org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.1.0"
  }
}

def jvmEncoding = java.nio.charset.Charset.defaultCharset().name()
if (jvmEncoding != "UTF-8") {
  throw new IllegalStateException("Build environment must be UTF-8 (it is: $jvmEncoding) - add '-Dfile.encoding=UTF-8' to the GRADLE_OPTS environment variable ")
}

if (!JavaVersion.current().java8Compatible) {
  throw new IllegalStateException("Must be built with Java 8 or higher")
}

apply plugin: 'artifactory'
apply plugin: 'com.github.kt3k.coveralls'

artifactory {
  contextUrl = 'http://oss.jfrog.org'
}

artifactoryPublish {
  skip true
}

task bintrayPublish << {
  if (!(ratpackBintrayUser && ratpackBintrayApiKey)) {
    throw new InvalidUserDataException("You must provide ratpackBintrayUser and ratpackBintrayApiKey")
  }

  if (!project.hasProperty('buildNumber')) {
    throw new GradleException("Must provide buildNumber of a release binary from oss.jfrog.org")
  }

  def baseUrl = 'https://oss.jfrog.org/api/plugins/build/promote/releaseToBintray/ratpack/'
  def params = '?params=org=ratpack|repo=maven|package=ratpack'
  def curlUrl = [baseUrl, project.buildNumber, params].join('')
  def curl = ['curl', '-X', 'POST', '-u',
              /"${ratpackBintrayUser}:${ratpackBintrayApiKey}"/, /"${curlUrl}"/].execute()
  logger.info("Received response: ${curl.text}")
}

allprojects {
  group = "io.ratpack"
  version = rootProject.file("shared-resources/ratpack/ratpack-version.txt").text.trim()

  apply plugin: "base"
  apply plugin: "idea"
  apply plugin: "eclipse"
  apply plugin: "java"
  apply plugin: "jacoco"
  apply from: "$rootDir/gradle/dependencyRules.gradle"

  repositories {
    jcenter()
    maven { url 'http://oss.jfrog.org/artifactory/repo' }
  }

  jacoco {
    toolVersion = "0.7.2.201409121644"
  }
}

apply from: "gradle/idea/idea.gradle"

ext {
  isSnapshot = version.endsWith("SNAPSHOT")
  isTravis = System.getenv("TRAVIS") != null
  isDrone = System.getenv("DRONE") != null
  isCodeship = System.getenv("CI_NAME") == "codeship"
  isSnapCi = System.getenv("SNAP_CI") != null
  isAppveyor = System.getenv("APPVEYOR") != null
  isCloudCi = isTravis || isDrone || isCodeship || isSnapCi || isAppveyor
  isHeroku = System.getenv("HEROKU") != null

  publishedModules = [
    "ratpack-core", "ratpack-groovy", "ratpack-guice", "ratpack-session", "ratpack-test", "ratpack-groovy-test",
    "ratpack-manual", "ratpack-gradle", "ratpack-handlebars", "ratpack-remote", "ratpack-remote-test", "ratpack-jackson",
    "ratpack-codahale-metrics", "ratpack-h2", "ratpack-thymeleaf", "ratpack-rx", "ratpack-hikari", "ratpack-newrelic",
    "ratpack-pac4j", "ratpack-hystrix", "ratpack-spring-boot", "ratpack-config"
  ].collect { project(it) }

  apiModules = publishedModules.findAll { !(it.name in ["ratpack-manual", "ratpack-gradle"]) }

  localRepoUrl = "${buildDir.toURI()}/localrepo"
}

apply from: "gradle/dependencies.gradle"

subprojects {
  tasks.withType(Upload).matching { it.name != "install" }.all {
    rootProject.subprojects {
      mustRunAfter tasks.matching { it instanceof VerificationTask }
    }
  }

  // CodeNarc appears to hang in drone.io
  tasks.withType(CodeNarc) {
    onlyIf { !rootProject.hasProperty("ciBuild") }
  }

  tasks.withType(Test) {
    allprojects {
      mustRunAfter tasks.withType(Checkstyle)
    }
  }

  tasks.withType(GroovyCompile) {
    allprojects {
      mustRunAfter tasks.withType(CodeNarc)
    }
  }

  apply from: "$rootDir/gradle/ratpackLocal.gradle"

  tasks.withType(Javadoc) {
    options.encoding = "utf-8"
    options.docEncoding = "utf-8"
    options.charSet = "utf-8"
    exclude "**/internal/**"
  }

  apply plugin: "maven"
  apply from: "${rootDir}/gradle/pom.gradle"
  apply plugin: "signing"

  if (rootProject.hasProperty("ciBuild")) {
    plugins.withType(ReportingBasePlugin) {
      reporting.baseDir = rootProject.file("build/reports/$name")
    }
  }

  jacocoTestReport {
    additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
    sourceDirectories = files(sourceSets.main.allSource.srcDirs)
    classDirectories = files(sourceSets.main.output)
    reports {
      html.enabled = true
      xml.enabled = true
      csv.enabled = false
    }
  }
}

// Have to evaluate the children before setting up the publishing stuff so the dependencies are defined.
evaluationDependsOnChildren()

subprojects {
  configurations.signatures.artifacts.all {
    extension = toSignArtifact.extension + "." + extension
  }

  if (project in publishedModules) {
    apply plugin: "artifactory"
    artifactoryPublish { task ->
      rootProject.artifactory {
        publish {
          repository {
            repoKey = isSnapshot ? 'oss-snapshot-local' : 'oss-release-local'
            gradle.taskGraph.whenReady { taskGraph ->
              if (taskGraph.hasTask(task)) {
                username = ratpackBintrayUser
                password = ratpackBintrayApiKey
              }
            }
          }
        }
      }
    }

    assert description: "Project $project.path is published, must have a description"

    modifyPom {
      project {
        name project.name
        description project.description
        url "http://www.ratpack.io"
        licenses {
          license {
            name "The Apache Software License, Version 2.0"
            url "http://www.apache.org/licenses/LICENSE-2.0.txt"
            distribution "repo"
          }
        }
        scm {
          connection "scm:https://ratpack@github.com/ratpack/ratpack"
          developerConnection "scm:git@github.com:ratpack/ratpack.git"
          url "https://github.com/ratpack/ratpack"
        }
        developers {
          developer {
            id "ratpack"
            name "Team Ratpack"
          }
        }
      }
    }
  }

  tasks.withType(Test) {
    testLogging {
      exceptionFormat "full"
      if (isCloudCi) {
        events "failed", "started"
        showStandardStreams true
      } else {
        events "failed"
      }
    }

    jvmArgs "-Xss320k"
    // Same min and max heap to fail fast if we can't allocate memory
    minHeapSize "312m"
    maxHeapSize "312m"

    if (isCloudCi) {
      doFirst {
        maxParallelForks 1
        if (isTravis) {
          forkEvery 1
        }
      }
    }
  }
}

task ciZip(type: Zip) {
  into "reports", { from "build/reports" }
  into "manual", { from { project(":ratpack-manual").packageManual } }
  archiveName = "ci.zip"
  destinationDir = buildDir
}

task stage {
  dependsOn "clean", ":ratpack-site:installApp"
}

task jacocoReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
  dependsOn publishedModules.test
  sourceDirectories = files(publishedModules.sourceSets.main.allSource.srcDirs)
  classDirectories = files(publishedModules.sourceSets.main.output)
  executionData = files(publishedModules.jacocoTestReport.executionData)
  reports {
    html.enabled = true
    xml.enabled = true
    csv.enabled = false
  }
}

coveralls {
  service = System.getenv().get("CI_NAME")
  sourceDirs = jacocoReport.sourceDirectories.files.toList()
  jacocoReportPath = jacocoReport.reports.xml.destination.absolutePath - rootDir.absolutePath
}

task testReport(type: TestReport) {
  destinationDir file("$buildDir/tests")
  reportOn subprojects.collect { it.tasks.test }
}

task allDependencies << {
  allprojects { p ->
    configurations.each { c ->
      println "Downloading dependencies for $p.path - $c.name"
      c.files
    }
  }
}

// Maven POM generation is not thread safe, so serialize all the Upload tasks we can use `--parallel`.
def lock = new ReentrantLock()
def available = lock.newCondition()
def busy = new AtomicBoolean()
allprojects {
    tasks.withType(Upload) { uploadTask ->
        doFirst {
            lock.lock()
            while (busy.get()) {
                available.await()
            }
            busy.set(true)
        }
    }
}
gradle.taskGraph.afterTask {
    if (it instanceof Upload && lock.heldByCurrentThread) {
        busy.set(false)
        available.signal()
        lock.unlock()
    }
}