build.gradle

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'de.richsource.gradle.plugins:gwt-gradle-plugin:0.6'
    classpath 'io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.5.3'
  }
}

plugins {
  id 'checkstyle'
  id 'eclipse'
  id 'java'
  id 'com.bmuschko.nexus' version '2.3.1'
  id 'com.palantir.git-version' version '0.2.0' 
}
apply plugin: 'io.codearte.nexus-staging'

repositories {
  mavenCentral()
}

sourceSets {
  main     // Code generation utilities (org.inferred.internal.source)
  testing  // Testing utilities (org.inferred.internal.source-testing)
  test     // Unit and integration tests for both main and testing
}

sourceCompatibility = 1.6
targetCompatibility = 1.6

compileTestJava {
  sourceCompatibility = 1.8
  targetCompatibility = 1.8
}
compileTestingJava {
  sourceCompatibility = 1.8
  targetCompatibility = 1.8
}

dependencies {
  compile commonsLang3
  compile(googleJavaFormat) {
    // Exclude transitive dependencies that don't affect the formatter
    exclude module: 'jcommander'
    exclude module: 'org.eclipse.equinox.app'
    exclude module: 'org.eclipse.core.filesystem'
    exclude module: 'org.eclipse.text'
    exclude module: 'org.eclipse.equinox.registry'
  }
  compile guava

  testingCompile javassist
  testingCompile junit
  testingCompile truth

  testCompile guavaTestlib
  testCompile hamcrest
  testCompile mockito
}

tasks.withType(Test) {
  testLogging {
    events "passed", "skipped", "failed"
  }
}

//// Testing JAR /////////////////////////////////////////////////

configurations {
  testingCompile.extendsFrom compile
  testingCompileOnly.extendsFrom compileOnly
  testCompile.extendsFrom testingCompile
  testCompileOnly.extendsFrom testingCompileOnly
}

sourceSets {
  testing {
    java {
      compileClasspath += main.output
      runtimeClasspath += main.output
    }
  }
  test {
    java {
      compileClasspath += testing.output
      runtimeClasspath += testing.output
    }
  }
}

task testingJar(type: Jar) {
  group = BasePlugin.BUILD_GROUP
  description = 'Assembles a jar archive containing the testing classes.'
  dependsOn tasks.testingClasses
  baseName = 'source-testing'
  from tasks.compileTestingJava.outputs, tasks.processTestingResources.outputs
  assemble.dependsOn it
}

artifacts {
  archives testingJar
}

afterEvaluate {
  if (extraArchive.javadoc) {
    task testingJavadoc(type: Javadoc) {
      group = JavaBasePlugin.DOCUMENTATION_GROUP
      description = 'Generates Javadoc API documentation for the testing source code.'
      classpath = sourceSets.testing.output + sourceSets.testing.compileClasspath
      source = sourceSets.testing.allJava
      destinationDir = file("$docsDir/testing-javadoc")
      title = "source-testing $version"
    }

    task testingJavadocJar(type: Jar) {
      group = BasePlugin.BUILD_GROUP
      description = 'Assembles a jar archive containing the generated Javadoc ' +
          'API documentation of the testing source code.'
      baseName = 'source-testing'
      classifier = 'javadoc'
      from tasks.testingJavadoc
    }

    artifacts {
      archives testingJavadocJar
    }
  }

  if (extraArchive.sources) {
    task testingSourcesJar(type: Jar) {
      group = BasePlugin.BUILD_GROUP
      description = 'Assembles a jar archive containing the testing sources of ' +
          'this project.'
      baseName = 'source-testing'
      classifier = 'sources'
      from project.sourceSets.testing.allSource
    }

    artifacts {
      archives testingSourcesJar
    }
  }
}

//// Checkstyle //////////////////////////////////////////////////
checkstyle {
  toolVersion = "6.19"
  configProperties['config_loc'] = "$rootDir/config/checkstyle"
}

tasks.withType(Checkstyle).each { checkstyleTask ->
  checkstyleTask.doLast {
    reports.all { report ->
      def outputFile = report.destination
      if (outputFile.exists() && outputFile.text.contains("<error ")) {
        throw new GradleException("There were checkstyle warnings! See $outputFile")
      }
    }
  }
}

eclipse.project {
  natures 'net.sf.eclipsecs.core.CheckstyleNature'
  buildCommand 'net.sf.eclipsecs.core.CheckstyleBuilder'
}

import org.gradle.plugins.ide.eclipse.GenerateEclipseProject
tasks.withType(GenerateEclipseProject, { generateTask ->
  afterEvaluate {
    generateTask.projectModel.natures 'net.sf.eclipsecs.core.CheckstyleNature'
    generateTask.projectModel.buildCommand 'net.sf.eclipsecs.core.CheckstyleBuilder'
  }

  def taskName = generateTask.name.replaceAll('Project$','') + 'Checkstyle'
  def createTask = task(taskName) {
    ext.enabled = true
    ext.outputFile = { new File(generateTask.outputFile.parentFile, '.checkstyle') }
    outputs.file outputFile
    doLast {
      def output = file(outputFile)
      output.parentFile.mkdirs()
      output.delete()
      if (enabled) {
        output << """
          <?xml version="1.0" encoding="UTF-8"?>

          <fileset-config file-format-version="1.2.0" simple-config="false" sync-formatter="false">
            <local-check-config name="Gradle configuration file" location="${checkstyle.configFile}" type="external" description="">
              <additional-data name="protect-config-file" value="true"/>
            </local-check-config>
            <fileset name="all" enabled="true" check-config-name="Gradle configuration file" local="true">
              <file-match-pattern match-pattern=".java\$" include-pattern="true"/>
            </fileset>
            <filter name="DerivedFiles" enabled="true"/>
          </fileset-config>
        """.replaceFirst('\n', '').stripIndent()
      }
    }
    tasks.eclipse.dependsOn it
  }
  def cleanTaskName = 'clean' + taskName.substring(0, 1).toUpperCase() + taskName.substring(1, taskName.length())
  task(cleanTaskName, type: Delete) {
    delete createTask.outputFile
    tasks.cleanEclipse.dependsOn it
  }
})

//// Publication /////////////////////////////////////////////////
project.ext.testingPoms = []
afterEvaluate {
  project.ext.poms += project.ext.testingPoms
}

group = 'org.inferred.internal'
version = (System.env.TRAVIS_TAG ?: gitVersion()).replaceAll('^v','')

modifyPom {
  project {
    switch (artifactId) {
      case 'source':
        name 'Source'
        description 'A Java library for code generation'
        break
      case 'source-testing':
        name 'Source Testing'
        description 'A Java library for testing code generators'
        break
      default:
        throw new RuntimeException("Unexpected artifact ID $artifactId")
    }
    url 'https://github.com/inferred/source'

    scm {
      url 'https://github.com/inferred/source'
      connection 'scm:git:git://github.com/inferred/source.git'
      developerConnection 'scm:git:git@github.com:inferred/source.git'
    }

    licenses {
      license {
        name 'Apache 2.0'
        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
      }
    }

    developers {
      developer {
        id 'chrisalice'
        name 'Chris Purcell'
        email 'Chris.Purcell.39@gmail.com'
        timezone 'Europe/London'
      }
    }
  }
}

tasks.withType(Upload) {
  repositories.withType(MavenResolver) {
    pom = addFilter('source') { artifact, file ->
      artifact.name == 'source'
    }
    MavenPom testingPom = addFilter('source-testing') { artifact, file ->
      artifact.name == 'source-testing'
    }
    testingPoms += [ testingPom ]
    testingPom.scopeMappings.addMapping(
        MavenPlugin.COMPILE_PRIORITY,
        configurations.testingCompile,
        Conf2ScopeMappingContainer.COMPILE)
    testingPom.scopeMappings.addMapping(
        MavenPlugin.RUNTIME_PRIORITY,
        configurations.testingRuntime,
        Conf2ScopeMappingContainer.RUNTIME)
  }
}

if (System.env.PGP_KEY_ID) {
  ext['signing.keyId'] = System.env.PGP_KEY_ID
  ext['signing.password'] = System.env.PGP_PASSWORD
  ext['signing.secretKeyRingFile'] = System.env.PGP_SECRET_KEY_RING_FILE
}
ext['nexusUsername'] = System.env.NEXUS_USERNAME
ext['nexusPassword'] = System.env.NEXUS_PASSWORD

nexusStaging {
  packageGroup = 'org.inferred'
}

//// Eclipse /////////////////////////////////////////////////////
eclipse.classpath {
  // Only src/main/java is compiled with JDK 6
  file.withXml { xml ->
    node = xml.asNode()
    node.findAll { it.@kind == 'src' && it.@path != 'src/main/java' }.each { src ->
        node.remove(src)
    }
  }
  // Don't include test dependencies in the classpath
  plusConfigurations.clear()
  plusConfigurations += [ configurations.compileClasspath ]
}
void setFilter(project, path, filter) {
  project.file.withXml {
    if (asNode().find { it.name() == 'filteredResources' } == null) {
      asNode().append(new XmlParser().parseText("""
        <filteredResources>
          <filter>
            <id>""" + System.currentTimeMillis() + """</id>
            <name>${path}</name>
            <type>9</type>
            <matcher>
              <id>org.eclipse.ui.ide.multiFilter</id>
              <arguments>1.0-name-matches-true-false-${filter}</arguments>
            </matcher>
          </filter>
        </filteredResources>
      """))
    }
  }
}
// Exclude everything in src except src/main
setFilter(eclipse.project, 'src', 'main')

import org.gradle.plugins.ide.eclipse.model.EclipseModel
extensions.create("eclipseTesting", EclipseModel)
extensions.create("eclipseTest", EclipseModel)

import org.gradle.plugins.ide.eclipse.GenerateEclipseProject
import org.gradle.plugins.ide.eclipse.internal.LinkedResourcesCreator
task eclipseTestingProject(type: GenerateEclipseProject) {
  description = 'Generates the Eclipse testing project file.'
  inputFile = project.file('.testing/.project')
  outputFile = inputFile
  projectModel.name = project.name + '-testing'
  projectModel.buildCommand 'org.eclipse.jdt.core.javabuilder'
  projectModel.natures "org.eclipse.jdt.core.javanature"
  projectModel.natures 'net.sf.eclipsecs.core.CheckstyleNature'
  projectModel.buildCommand 'net.sf.eclipsecs.core.CheckstyleBuilder'
  projectModel.linkedResource name: 'src', type:'2', location: 'PARENT-1-PROJECT_LOC/src'
  setFilter(projectModel, 'src', 'testing')
  eclipseTesting.project = projectModel
  tasks.eclipse.dependsOn it
}
task cleanEclipseTestingProject(type: Delete) {
  delete file('.testing/.project')
  tasks.cleanEclipse.dependsOn it
}
task eclipseTestProject(type: GenerateEclipseProject) {
  description = 'Generates the Eclipse test project file.'
  inputFile = project.file('.test/.project')
  outputFile = inputFile
  projectModel.name = project.name + '-test'
  projectModel.buildCommand 'org.eclipse.jdt.core.javabuilder'
  projectModel.natures "org.eclipse.jdt.core.javanature"
  projectModel.natures 'net.sf.eclipsecs.core.CheckstyleNature'
  projectModel.buildCommand 'net.sf.eclipsecs.core.CheckstyleBuilder'
  projectModel.linkedResource name: 'src', type:'2', location: 'PARENT-1-PROJECT_LOC/src'
  setFilter(projectModel, 'src', 'test')
  eclipseTest.project = projectModel
  tasks.eclipse.dependsOn it
}
task cleanEclipseTestProject(type: Delete) {
  delete file('.test/.project')
  tasks.cleanEclipse.dependsOn it
}

import org.gradle.plugins.ide.eclipse.GenerateEclipseJdt
task eclipseTestingJdt(type: GenerateEclipseJdt) {
  description = 'Generates the Eclipse testing JDT settings file.'
  inputFile = project.file('.testing/.settings/org.eclipse.jdt.core.prefs')
  outputFile = inputFile
  eclipseTesting.jdt = jdt
  jdt.conventionMapping.map('sourceCompatibility') { JavaVersion.toVersion(compileTestingJava.sourceCompatibility) }
  jdt.conventionMapping.map('targetCompatibility') { JavaVersion.toVersion(compileTestingJava.targetCompatibility) }
  jdt.conventionMapping.map('javaRuntimeName') { 'JavaSE-' + jdt.targetCompatibility }
  tasks.eclipse.dependsOn it
}
task cleanEclipseTestingJdt(type: Delete) {
  delete file('.testing/.settings/org.eclipse.jdt.core.prefs')
  tasks.cleanEclipse.dependsOn it
}
task eclipseTestJdt(type: GenerateEclipseJdt) {
  description = 'Generates the Eclipse test JDT settings file.'
  inputFile = project.file('.test/.settings/org.eclipse.jdt.core.prefs')
  outputFile = inputFile
  eclipseTest.jdt = jdt
  jdt.conventionMapping.map('sourceCompatibility') { JavaVersion.toVersion(compileTestJava.sourceCompatibility) }
  jdt.conventionMapping.map('targetCompatibility') { JavaVersion.toVersion(compileTestJava.targetCompatibility) }
  jdt.conventionMapping.map('javaRuntimeName') { 'JavaSE-' + jdt.targetCompatibility }
  tasks.eclipse.dependsOn it
}
task cleanEclipseTestJdt(type: Delete) {
  delete file('.test/.settings/org.eclipse.jdt.core.prefs')
  tasks.cleanEclipse.dependsOn it
}

import org.gradle.api.internal.plugins.DslObject
import org.gradle.internal.xml.XmlTransformer
import org.gradle.plugins.ide.api.XmlFileContentMerger
import org.gradle.plugins.ide.eclipse.GenerateEclipseClasspath
import org.gradle.plugins.ide.eclipse.model.EclipseClasspath
task eclipseTestingClasspath(type: GenerateEclipseClasspath) {
  description = 'Generates the Eclipse testing classpath file.'
  inputFile = project.file('.testing/.classpath')
  outputFile = inputFile
  classpath = new EclipseClasspath(project)
  classpath.file = new XmlFileContentMerger((XmlTransformer) getProperty('xmlTransformer'))
  classpath.sourceSets = []
  project.afterEvaluate {
    Set<String> containers = new LinkedHashSet<>()
    containers.add(
        'org.eclipse.jdt.launching.JRE_CONTAINER/'
            + 'org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/'
            + eclipseTesting.jdt.javaRuntimeName + '/')
    containers.addAll(classpath.containers)
    classpath.containers = containers
  }
  classpath.plusConfigurations += [
    configurations.testingCompileClasspath
  ]
  classpath.defaultOutputDir = project.file('.testing/bin')
  dependsOn sourceSets.main.output.dirs
  dependsOn sourceSets.testing.output.dirs
  eclipseTesting.classpath = classpath
  tasks.eclipse.dependsOn it
}
task cleanEclipseTestingClasspath(type: Delete) {
  delete file('.testing/.classpath')
  tasks.cleanEclipse.dependsOn it
}
task eclipseTestClasspath(type: GenerateEclipseClasspath) {
  description = 'Generates the Eclipse test classpath file.'
  inputFile = project.file('.test/.classpath')
  outputFile = inputFile
  classpath = new EclipseClasspath(project)
  classpath.file = new XmlFileContentMerger((XmlTransformer) getProperty('xmlTransformer'))
  classpath.sourceSets = []
  project.afterEvaluate {
    Set<String> containers = new LinkedHashSet<>()
    containers.add(
        'org.eclipse.jdt.launching.JRE_CONTAINER/'
            + 'org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/'
            + eclipseTest.jdt.javaRuntimeName + '/')
    containers.addAll(classpath.containers)
    classpath.containers = containers
  }
  classpath.plusConfigurations += [
    configurations.testCompileClasspath
  ]
  classpath.defaultOutputDir = project.file('.test/bin')
  dependsOn sourceSets.main.output.dirs
  dependsOn sourceSets.testing.output.dirs
  dependsOn sourceSets.test.output.dirs
  eclipseTest.classpath = classpath
  tasks.eclipse.dependsOn it
}
task cleanEclipseTestClasspath(type: Delete) {
  delete file('.test/.classpath')
  tasks.cleanEclipse.dependsOn it
}

import org.gradle.plugins.ide.eclipse.model.ProjectDependency
import org.gradle.plugins.ide.eclipse.model.SourceFolder
eclipseTesting.classpath.file.beforeMerged {
  entries += [
    new SourceFolder('/' + project.name, null),
    new SourceFolder('src/testing/java', null)
  ]
}
eclipseTest.classpath.file.beforeMerged {
  entries += [
    new SourceFolder('/' + project.name, null),
    new SourceFolder('/' + project.name + '-testing', null),
    new SourceFolder('src/test/java', null)
  ]
}