build.gradle

// Build Script
// ============

if (System.env.TRAVIS == 'true') {
  allprojects {
    tasks.withType(GroovyCompile) {
      groovyOptions.fork = false
    }
    tasks.withType(Test) {
      maxParallelForks = 1
      maxHeapSize = '512m'
    }
  }
}

import groovy.io.FileType

buildscript {
  repositories {
    mavenLocal()
    maven {
      url 'https://plugins.gradle.org/m2/'
    }
    mavenCentral()
    jcenter()
  }
  dependencies {
    classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.5'
    classpath 'gradle.plugin.com.github.sherter.google-java-format:google-java-format-gradle-plugin:0.7.1'
    classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.0'
    classpath 'net.ltgt.gradle:gradle-apt-plugin:0.10'
  }
}


apply plugin: 'jacoco'
apply plugin: 'java'
apply plugin: 'maven'
apply plugin: 'idea'
apply plugin: 'eclipse'
apply plugin: 'com.google.protobuf'
apply plugin: 'com.github.sherter.google-java-format'
apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: 'signing'
apply plugin: 'net.ltgt.apt'

sourceCompatibility = 1.8

group = 'com.google.api'
project.version = file('version.txt').text.trim()

def protoVersion = '3.4.0'

// Dependencies
// ------------

ext {
  // Shortcuts for libraries we are using
  libraries = [
    // General
    apiCommon: 'com.google.api:api-common:1.1.0',
    apiCompiler: 'com.google.api:api-compiler:0.0.7',
    autovalue: 'com.google.auto.value:auto-value:1.6',
    autovalueAnnotation: 'com.google.auto.value:auto-value-annotations:1.6',
    commonmark: 'com.atlassian.commonmark:commonmark:0.9.0',
    commonProtos: 'com.google.api.grpc:grpc-google-common-protos:1.0.5',
    commonsLang: 'org.apache.commons:commons-lang3:3.6',
    commonsCli: 'commons-cli:commons-cli:1.4',
    gson: 'com.google.code.gson:gson:2.3',
    guava: 'com.google.guava:guava:25.0-jre',
    jacksonAnnotations: 'com.fasterxml.jackson.core:jackson-annotations:2.9.0',
    jacksonCore: 'com.fasterxml.jackson.core:jackson-core:2.9.0',
    jacksonDatabind: 'com.fasterxml.jackson.core:jackson-databind:2.9.0',
    jsr305: 'com.google.code.findbugs:jsr305:3.0.0',
    snakeyaml: 'org.yaml:snakeyaml:1.18',
    threetenbp: 'org.threeten:threetenbp:1.3.3',

    // Testing
    junit: 'junit:junit:4.12',
    mockito: 'org.mockito:mockito-core:2.+',
    truth: 'com.google.truth:truth:0.40',
    toolsFxTesting: 'com.google.api:api-compiler:0.0.6:testing',
    junitParams: 'pl.pragmatists:JUnitParams:1.1.1',

    // Protobuf
    protobuf: 'com.google.protobuf:protobuf-java:' + protoVersion,
    protoc:  'com.google.protobuf:protoc:' + protoVersion,

    // Formatter
    javaFormatter: 'com.google.googlejavaformat:google-java-format:1.6'
  ]
}

repositories {
  mavenLocal()
  mavenCentral()
}

dependencies {
  compile libraries.apiCommon,
    libraries.apiCompiler,
    libraries.autovalueAnnotation,
    libraries.commonmark,
    libraries.commonsCli,
    libraries.commonsLang,
    libraries.gson,
    libraries.guava,
    libraries.jacksonAnnotations,
    libraries.jacksonCore,
    libraries.jacksonDatabind,
    libraries.javaFormatter,
    libraries.jsr305,
    libraries.protobuf,
    libraries.snakeyaml,
    libraries.threetenbp,
    libraries.toolsFxTesting

  testCompile libraries.junit,
    libraries.truth,
    libraries.toolsFxTesting,
    libraries.mockito,
    libraries.commonProtos,
    libraries.junitParams

  annotationProcessor libraries.autovalue
}

task fatJar(type: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar) {
  classifier = 'fatjar'
  from sourceSets.main.output.filter {
    // This jar file needs to be excluded or else the shadow plugin will actually explode the classes into
    // the fat jar. We want to retain the file as a unit because we want to put it into the output directory.
    // StaticResourcesHandler performs the rename back to `gradle-wrapper.jar`.
    rename 'gradle-wrapper.jar', 'gradle-wrapper.zjar'
  }
  configurations = [ project.configurations.runtime ]
  exclude 'META-INF/*.SF'
  exclude 'META-INF/*.DSA'
  exclude 'META-INF/*.RSA'

  doLast {
    Symlinks.createSymbolicLink(
            "$buildDir/libs/gapic-generator-latest-fatjar.jar",
            "$buildDir/libs/gapic-generator-${project.version}-fatjar.jar")
  }
}

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

check.dependsOn jacocoTestReport

// Source jar
task sourcesJar(type: Jar, dependsOn: classes) {
  classifier = 'sources'
  from sourceSets.main.allSource
}

// Protobuf
// --------

sourceSets {
  main {
    proto {
      // Include proto sources for GAPIC generator config.
      srcDir 'src/main/proto'
    }
    java {
      // Include location where proto plugin puts generated sources.
      srcDir "${buildDir}/generated/source/proto/main/java"
    }
  }
}

protobuf {
  protoc {
    artifact = libraries.protoc
  }
}

// JavaDoc
// -------

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

javadoc.options {
  encoding = 'UTF-8'
  links 'https://docs.oracle.com/javase/7/docs/api/'
}

// Test data
// ---------

sourceSets {
  test {
    resources {
      // Include all resources from testdata and testsrc folders.
      srcDir 'src/test/java'
      include '**/testdata/**'
      include '**/testsrc/**'
    }
    resources {
      // Include protos of core platform and gapic-generator,
      // as some tests depend on this.
      srcDir "${projectDir}/modules/googleapis"
      include '**/*.proto'
    }
  }
}

task setupProtocEnvironment {
  doLast {
    def protocPath = project.configurations.protobufToolsLocator_protoc.resolve().getAt(0)
    if (protocPath == null) {
      throw new RuntimeException("protoc path is null")
    }
    test.setEnvironment(PROTOC_COMPILER: protocPath)
  }
}

test.dependsOn setupProtocEnvironment

task showRuntimeClassPath {
  doLast {
    println 'output: ' + sourceSets.main.runtimeClasspath.asPath
  }
}

// Test Logging
// ============
test {
  testLogging {
      events 'passed', 'skipped', 'failed', 'standardOut', 'standardError'
  }
}

// Eclipse Annotation Processing
// -----------------------------

// TODO(wrwg): figure whether there is direct support for this in eclipse plugin,
// and use that instead.

ext {
  eclipseAptFolder = '.apt_generated'
  eclipseSettingsDir = file('.settings')
}

configurations {
  codeGeneration
}

dependencies {
  codeGeneration libraries.autovalue, libraries.jsr305
}

compileJava.classpath += configurations.codeGeneration

eclipse {
  jdt.file.withProperties {
    it['org.eclipse.jdt.core.compiler.processAnnotations'] = 'enabled'
  }
}

tasks.eclipseJdt {
  doFirst {
    def aptPrefs =
        file("${eclipseSettingsDir}/org.eclipse.jdt.apt.core.prefs")
    aptPrefs.parentFile.mkdirs()

    aptPrefs.text = """\
        eclipse.preferences.version=1
        org.eclipse.jdt.apt.aptEnabled=true
        org.eclipse.jdt.apt.genSrcDir=${eclipseAptFolder}
        org.eclipse.jdt.apt.reconcileEnabled=true
        """.stripIndent()

    file('.factorypath').withWriter {
      new groovy.xml.MarkupBuilder(it).'factorypath' {
        project.configurations.codeGeneration.each { dep->
          factorypathentry(
            kind:'EXTJAR',
            id:dep.absolutePath,
            enabled:true,
            runInBatchMode:false)
        }
      }
    }
  }
}

tasks.cleanEclipseJdt {
  doFirst {
    delete file("${eclipseSettingsDir}/org.eclipse.jdt.apt.core.prefs"),
      file('.factorypath')
  }
}

artifacts {
  archives javadocJar, sourcesJar
}

signing {
  required { gradle.taskGraph.hasTask('uploadArchives') }
  sign configurations.archives
}

if (project.hasProperty('ossrhUsername') && project.hasProperty('ossrhPassword')) {
  uploadArchives {
    repositories {
      mavenDeployer {
        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

        repository(url: 'https://oss.sonatype.org/service/local/staging/deploy/maven2/') {
          authentication(userName: ossrhUsername, password: ossrhPassword)
        }

        snapshotRepository(url: 'https://oss.sonatype.org/content/repositories/snapshots/') {
          authentication(userName: ossrhUsername, password: ossrhPassword)
        }

        pom.project {
          name 'GAPIC Generator'
          packaging 'jar'
          artifactId 'gapic-generator'
          description 'GAPIC Generator'
          url 'https://github.com/googleapis/gapic-generator'

          scm {
            url 'https://github.com/googleapis/gapic-generator'
            connection 'scm:git:https://github.com/googleapis/gapic-generator.git'
          }

          licenses {
            license {
              name 'The Apache License, Version 2.0'
              url 'https://www.apache.org/licenses/LICENSE-2.0.txt'
            }
          }

          developers {
            developer {
              id 'GoogleAPIs'
              name 'GoogleAPIs'
              email 'googleapis@googlegroups.com'
              url 'https://github.com/googleapis'
              organization 'Google LLC'
              organizationUrl 'https://www.google.com'
            }
          }
        }
      }
    }
  }
} else {
  task failUploadArchives {
    doLast {
      throw new GradleException('uploadArchives needs ossrhUsername and ossrhPassword '
        + 'to be set. They can be set inside your ~/.gradle/gradle.properties file.')
    }
  }
  tasks.uploadArchives.dependsOn(failUploadArchives)
}

allprojects {
  gradle.projectsEvaluated {
    tasks.withType(JavaCompile) {
      options.compilerArgs << '-Xlint:unchecked'
    }
  }
}

task createProperties(dependsOn: processResources) {
  doLast{
    new File("$buildDir/resources/main/com/google/api/codegen/").mkdirs()
    Properties p = new Properties()
    p['version'] = project.version.toString()
    p.store(new PrintWriter("$buildDir/resources/main/com/google/api/codegen/codegen.properties", 'UTF-8'), null)
  }
  outputs.file("$buildDir/resources/main/com/google/api/codegen/codegen.properties")
}

classes {
  dependsOn createProperties
}

// Task to build symlinks to tools related to code generation.
// Symlinks will be placed under `build/toolpaths`.
task createToolPaths {
  doLast {
    new File("$buildDir/toolpaths/").mkdirs()
    DependencyResolver resolver = new DependencyResolver(project)

    def protoGenGrpcJavaExe = resolver.resolveExecutable(
            'io.grpc:protoc-gen-grpc-java:1.10.0')
    Symlinks.createSymbolicLink("$buildDir/toolpaths/protoGenGrpcJavaExe", protoGenGrpcJavaExe)

    def protobufJavaDir = resolver.extractArchive(
            'com.google.protobuf:protobuf-java:' + protoVersion)
    Symlinks.createSymbolicLink("$buildDir/toolpaths/protobufJavaDir", protobufJavaDir)

    def googleJavaFormatJar = resolver.locateArchive(
            'com.google.googlejavaformat:google-java-format:1.1:all-deps')
    Symlinks.createSymbolicLink("$buildDir/toolpaths/googleJavaFormatJar", googleJavaFormatJar)
  }
}


task verifyLicense {
  doLast {
    def licenseText = new File(rootProject.rootDir, 'license-header-javadoc.txt').text
    def srcFiles = []
    sourceSets
        .collectMany{it.allJava.getSrcDirs()}
        .each{it.eachFileRecurse(FileType.FILES, {srcFiles << new Tuple(it, it.text)})}
    srcFiles = srcFiles
        .findAll{!it.get(0).path.contains('/generated/') && it.get(0).path.endsWith('.java')}
        .collect{new Tuple(it.get(0), it.get(1).replaceAll("Copyright 20[0-9]{2}", 'Copyright 20xx'))}
        .findAll{!it.get(1).startsWith(licenseText)}
    if (srcFiles.asList().size() > 0) {
      srcFiles.each({println 'missing license: ' + it.get(0)})
      throw new IllegalStateException('Above files do not have licenses')
    }
  }
}

test.dependsOn verifyLicense

tasks.googleJavaFormat {
  exclude '.apt_generated/**'
  exclude 'bin/**'
  exclude 'build/**'
  exclude 'benchmark/**'
  exclude 'modules/googleapis/third_party'
  exclude 'bazel-*'
}
tasks.verifyGoogleJavaFormat {
  exclude '.apt_generated/**'
  exclude 'bin/**'
  exclude 'build/**'
  exclude 'benchmark/**'
  exclude 'modules/googleapis/third_party'
  exclude 'bazel-*'
}
test.dependsOn verifyGoogleJavaFormat