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.10'
    classpath 'gradle.plugin.com.github.sherter.google-java-format:google-java-format-gradle-plugin:0.8'
    classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
    classpath 'net.ltgt.gradle:gradle-apt-plugin:0.21'
  }
}


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()

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

jacoco {
  toolVersion = "0.8.5"
}

ext {
  // Load Dependencies shared between Bazel and Gradle build scripts
  libraries = new Properties()
  file("dependencies.properties").withReader{ libraries.load((Reader) it) }

  // Gradle-specific build script dependencies
  libraries.putAll([
    protobuf: 'com.google.protobuf:protobuf-java:' + libraries['version.com_google_protobuf'],
    protoc:  'com.google.protobuf:protoc:' + libraries['version.com_google_protobuf'],
    javaFormatter: 'com.google.googlejavaformat:google-java-format:' + libraries['version.google_java_format'],
  ])
}

repositories {
  mavenLocal()
  mavenCentral()
}

dependencies {
  compile libraries['maven.com_google_api_api_common'],
    libraries['maven.com_google_api_api_compiler'],
    libraries['maven.com_google_auto_value_auto_value_annotations'],
    libraries['maven.com_atlassian_commonmark_commonmark'],
    libraries['maven.commons_cli_commons_cli'],
    libraries['maven.org_apache_commons_commons_lang3'],
    libraries['maven.com_google_guava_guava__com_google_api_codegen'],
    libraries['maven.com_fasterxml_jackson_core_jackson_annotations'],
    libraries['maven.com_fasterxml_jackson_core_jackson_core'],
    libraries['maven.com_fasterxml_jackson_core_jackson_databind'],
    libraries['javaFormatter'],
    libraries['maven.com_google_code_findbugs_jsr305'],
    libraries['protobuf'],
    libraries['maven.org_yaml_snakeyaml'],
    libraries['maven.org_threeten_threetenbp'],
    libraries['maven.com_google_api_grpc_proto_google_common_protos__com_google_api_codegen'],
    libraries['maven.com_google_api_api_compiler_testing'],
    libraries['maven.com_google_protobuf_protobuf_java_util']

  testCompile libraries['maven.junit_junit'],
    libraries['maven.com_google_truth_truth'],
    libraries['maven.com_google_api_api_compiler_testing'],
    libraries['maven.org_mockito_mockito_core'],
    libraries['maven.pl_pragmatists_JUnitParams']

  annotationProcessor libraries['maven.com_google_auto_value_auto_value']
}

task protocPluginJar(type: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar) {
  manifest {
    attributes 'Main-Class': 'com.google.api.codegen.ProtocGeneratorMain'
  }

  baseName = 'protoc-plugin-gapic-generator'

  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/protoc-plugin-gapic-generator-latest-fatjar.jar",
            "$buildDir/libs/protoc-plugin-gapic-generator-${project.version}-fatjar.jar")
  }
}

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['maven.com_google_auto_value_auto_value'],
    libraries['maven.com_google_code_findbugs_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.30.2')
    Symlinks.createSymbolicLink("$buildDir/toolpaths/protoGenGrpcJavaExe", protoGenGrpcJavaExe)

    def protobufJavaDir = resolver.extractArchive(
            'com.google.protobuf:protobuf-java:' + libraries["version.com_google_protobuf"])
    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')
    }
  }
}

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