build.gradle

buildscript {
  repositories {
    jcenter()
    mavenCentral()
    mavenLocal()
  }
  dependencies {
    classpath "org.apache.commons:commons-lang3:$commonsLang3Version"
    classpath 'org.apache.commons:commons-text:1.1'
  }
}

plugins {
  id 'nebula.kotlin' version '1.2.50'
  id 'org.jmailen.kotlinter' version '1.11.2'
  id 'io.gitlab.arturbosch.detekt' version '1.0.0.RC6-4'
  id 'org.jetbrains.dokka' version '0.9.16'
}

repositories {
  mavenLocal()
  mavenCentral()
  jcenter()
}

import org.apache.commons.text.StringEscapeUtils

subprojects {
  buildscript {
    repositories {
      jcenter()
      mavenCentral()
      mavenLocal()
    }
  }

    def scalaVersionLookup = [
        '2.12': '2.12.5'
    ]

    def m = project.name =~ /.*_(2\.1\d)(_0\.\d+)?/
    if (m.matches()) {
      project.ext {
          scalaVersion = m.group(1)
          scalaFullVersion = scalaVersionLookup[m.group(1)]
      }

      buildDir = new File(projectDir, "build/$project.scalaVersion")
    }

    apply plugin: 'java'
    if (project.hasProperty('scalaVersion')) {
      apply plugin: 'scala'
    }
    apply plugin: 'groovy'
    apply plugin: 'maven'
    apply plugin: 'signing'
    apply plugin: 'codenarc'
    apply plugin: 'jacoco'
    apply plugin: 'org.jetbrains.kotlin.jvm'
    apply plugin: 'org.jmailen.kotlinter'
    apply plugin: 'io.gitlab.arturbosch.detekt'
    apply plugin: 'org.jetbrains.dokka'

    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
    }

    dependencies {
      compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
      compile "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
      compile "org.slf4j:slf4j-api:${project.slf4jVersion}"
      compile "org.codehaus.groovy:groovy-all:${project.groovyVersion}:indy"
      compile('io.github.microutils:kotlin-logging:1.4.4') {
        exclude group: 'org.jetbrains.kotlin'
      }

      if (project.hasProperty('scalaVersion')) {
          compile "org.scala-lang:scala-library:${project.scalaFullVersion}"
          compile("com.typesafe.scala-logging:scala-logging_${project.scalaVersion}:3.7.2") {
            exclude group: 'org.scala-lang'
          }

          testCompile "org.specs2:specs2-core_${project.scalaVersion}:${project.specs2Version}",
            "org.specs2:specs2-junit_${project.scalaVersion}:${project.specs2Version}"
      }

      testCompile 'org.hamcrest:hamcrest-all:1.3',
        'org.mockito:mockito-core:1.10.19',
        "junit:junit:${project.junitVersion}"

      testCompile('org.spockframework:spock-core:1.1-groovy-2.4') {
        exclude group: 'org.codehaus.groovy'
      }
      testCompile "cglib:cglib:${project.cglibVersion}"
      testCompile 'org.objenesis:objenesis:2.6'
      testCompile 'io.kotlintest:kotlintest:2.0.7'
    }

    group = 'au.com.dius'
    version = '3.5.20'
    targetCompatibility = '1.8'
    sourceCompatibility = '1.8'

    tasks.withType(ScalaCompile) {
        scalaCompileOptions.additionalParameters = ['-target:jvm-1.8']
        configure(scalaCompileOptions.forkOptions) {
          memoryMaximumSize = '256m'
        }
    }

    if (project.hasProperty('scalaVersion')) {
      compileScala {
        classpath = classpath.plus(files(compileGroovy.destinationDir)).plus(files(compileKotlin.destinationDir))
        dependsOn compileGroovy, compileKotlin
      }
    }

    compileTestGroovy {
      classpath = classpath.plus(files(compileTestKotlin.destinationDir))
      dependsOn compileTestKotlin
    }

    tasks.withType(GroovyCompile) {
      groovyOptions.optimizationOptions.indy = true
    }

    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
      kotlinOptions {
        jvmTarget = "1.8"
        apiVersion = "1.1"
      }
    }

    task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
      outputFormat = 'javadoc'
      outputDirectory = "$buildDir/docs/dokkaJavadoc"
    }

    test {
      systemProperty 'pact.rootDir', "$buildDir/pacts"
    }

    jar {
        manifest.attributes provider: 'gradle',
                'Implementation-Title': project.name, 'Implementation-Version': version,
                'Implementation-Vendor': project.group, 'Implementation-Vendor-Id': project.group,
                'Specification-Vendor': project.group,
                'Specification-Title': project.name,
                'Specification-Version': version
    }

    task javadocJar(type: Jar, dependsOn: [javadoc, groovydoc, dokkaJavadoc]) {
        classifier = 'javadoc'
      if (project.hasProperty('scalaVersion')) {
        from javadoc.destinationDir, scaladoc.destinationDir, groovydoc.destinationDir, dokkaJavadoc.outputDirectory
        dependsOn << scaladoc
      } else {
        from javadoc.destinationDir, groovydoc.destinationDir, dokkaJavadoc.outputDirectory
      }
    }

    task sourceJar(type: Jar) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    artifacts {
        archives javadocJar
        archives sourceJar
    }

    def pomCustomisation = {
        name project.name
        description StringEscapeUtils.escapeXml11(new File(projectDir, 'README.md').text)
        url 'https://github.com/DiUS/pact-jvm'
        licenses {
            license {
                name 'Apache 2'
	            url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
	            distribution 'repo'
            }
        }
        scm {
            url 'https://github.com/DiUS/pact-jvm'
            connection 'https://github.com/DiUS/pact-jvm.git'
        }

	    developers {
            developer {
                id 'thetrav'
                name 'Travis Dixon'
                email 'the.trav@gmail.com'
            }
            developer {
                id 'rholshausen'
                name 'Ronald Holshausen'
                email 'rholshausen@dius.com.au'
            }
        }
    }

    uploadArchives {
        repositories {
            mavenDeployer {

                beforeDeployment { def deployment -> signing.signPom(deployment) }

                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    if (project.hasProperty('sonatypeUsername')) {
                        authentication(userName: sonatypeUsername, password: sonatypePassword)
                    }
//                     proxy(host: 'localhost', port: 3128, type: 'http')
                }

            }
        }
    }

    ext.installer = install.repositories.mavenInstaller
    ext.deployer = uploadArchives.repositories.mavenDeployer
    installer.pom.project(pomCustomisation)
    deployer.pom.project(pomCustomisation)

    signing {
        required { gradle.taskGraph.hasTask("uploadArchives") || gradle.taskGraph.hasTask("publishPlugins") }
        sign configurations.archives
    }

    codenarcMain {
        configFile = file('../config/codenarc/ruleset.groovy')
    }

    codenarcTest {
        configFile = file('../config/codenarc/rulesetTest.groovy')
    }

    check.dependsOn << 'jacocoTestReport'

  kotlinter {
    indentSize = 2
    continuationIndentSize = 2
    reporters = ['checkstyle', 'plain', 'json']
  }

  detekt {
    profile("main") {
      config = "${project.parent.projectDir}/config/detekt-config.yml"
      if (file("$projectDir/src/main/kotlin").exists()) {
        input = "$projectDir/src/main/kotlin"
      }
    }
    profile("test") {
      config = "${project.parent.projectDir}/config/detekt-config-test.yml"
      if (file("$projectDir/src/test/kotlin").exists()) {
        input = "$projectDir/src/test/kotlin"
      }
    }
  }

  check.dependsOn << 'detektCheck'

  task allDeps(type: DependencyReportTask) {}
}

tasks.addRule("Pattern: <Task>_<ScalaVersion>") { String taskName ->
  if (taskName.contains('_')) {
    def m = taskName =~ $/(.*)_(\d\.\d+)/$
    if (m.matches()) {
      task(taskName) {
        dependsOn project.childProjects.findAll { it.key.endsWith('_' + m.group(2)) }
          .collect { it.value.getTasksByName(m.group(1), false) }.flatten()
      }
    } else {
      task(taskName) {
        dependsOn project.childProjects.findAll { !(it.key ==~ /.*_\d\.\d+$/) }
          .collect { it.value.getTasksByName(taskName.split('_').first(), false) }.flatten()
      }
    }
  }
}

if (System.env.TRAVIS == 'true') {
    allprojects {
        tasks.withType(GroovyCompile) {
            groovyOptions.fork = false
        }
        tasks.withType(Test) {
            // containers (currently) have 2 dedicated cores and 4GB of memory
//            maxParallelForks = 2
            minHeapSize = '128m'
            maxHeapSize = '768m'
        }
    }
}