build.gradle

import static groovy.io.FileType.FILES

// TODO: deploy not only jar but also sources and javadoc, to pass validation by Sonatype nexus
// apply from: "$rootDir/gradle/maven.gradle"
plugins {
  id 'org.ajoberstar.grgit' version '4.1.1'
  id "eclipse-convention"
}

def readLastCommitHash() {
  // Same as 'git log -1 --pretty=format:"%h"'.execute().getText()
  org.ajoberstar.grgit.Grgit.open(dir: rootDir).head().abbreviatedId
}

if (version.endsWith('-SNAPSHOT')) {
  // eclipse doesn't like the `-SNAPSHOT`, so we timestamp uniquely
  version = version - '-SNAPSHOT' + '.' + new Date().format('yyyyMMddHHmm') + '-' + readLastCommitHash()
} else if (version.contains('-RC')) {
  // eclipse doesn't like the `-RC`, so we timestamp uniquely
  version = version.substring(0, version.lastIndexOf('-RC')) + '.' + new Date().format('yyyyMMddHHmm') + '-' + readLastCommitHash()
} else if (version.contains('-beta')) {
  // eclipse doesn't like the `-beta`, so we timestamp uniquely
  version = version.substring(0, version.lastIndexOf('-beta')) + '.' + new Date().format('yyyyMMddHHmm') + '-' + readLastCommitHash()
} else {
  // A release build version like 3.0.0 without qualifier will always be smaller
  // then nightly build 3.0.0.20171023-1508734123102, but to update from nightlies
  // we must give Eclipse a higher version number.
  // The "r" makes the release version to be always higher then nightly builds
  version = version + '.r' + new Date().format('yyyyMMddHHmm') + '-' + readLastCommitHash()
}

sourceSets {
  main {
    java {
      srcDirs = ['src']
    }
    resources {
      srcDirs = ['src']
      include '**/*.properties'
      include '**/*.xml'
    }
  }
}

def findEclipseExecutable() {
  if (!file("$projectDir/local.properties").exists()) {
    return null
  }

  def localProps = new Properties()
  localProps.load(new FileInputStream("$projectDir/local.properties"))
  def eclipseRootDir = file(localProps.getProperty('eclipseRoot.dir'))
  // Eclipse 4.5+ uses a different directory layout under macOS. Try to detect this first.
  def eclipseExecutable = new File(eclipseRootDir, "Contents/MacOS/eclipse")
  if (!eclipseExecutable.exists()) {
    // Fall back to non-macOS directory layout.
    eclipseExecutable = new File(eclipseRootDir, "eclipse")
  }
  return eclipseExecutable
}

def eclipsePluginId = 'com.github.spotbugs.plugin.eclipse'
def eclipseExecutable = findEclipseExecutable()

dependencies {
  api (project(':spotbugs')) {
    transitive = true
  }
}

tasks.named('clean', Delete).configure {
    delete "lib", "build"
}

// This disables hundreds of javadoc warnings on missing tags etc, see #340
tasks.named('javadoc', Javadoc).configure {
  // This is supposed to enable everything except "missing" but doesn't work with gradle
  // See http://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html
  options.addBooleanOption('Xdoclint:all,-missing', true)

  // TODO remove command and warning below if the doclint can be properly configured
  options.addStringOption('Xmaxwarns', '3')

  doLast {
    logger.warn('Javadoc: too many warnings, only first 3 are shown, see #340!')
  }
}

def copyLibsForEclipse = tasks.register('copyLibsForEclipse', Copy) {
    from (configurations.runtimeClasspath) {
      include "*.jar"
    }
    into "lib"
}

def distSrcZip = tasks.register('distSrcZip', Exec) {
  def out = "${buildDir}/distributions/${eclipsePluginId}_${project.version}-source.zip"
  outputs.file out
  commandLine 'git', 'archive', '-o', out, 'HEAD'
}

def updateManifest = tasks.register('updateManifest') {
  inputs.file "$projectDir/META-INF/MANIFEST-TEMPLATE.MF"
  outputs.file "$projectDir/META-INF/MANIFEST.MF"
  outputs.file "$projectDir/META-INF/MANIFEST-DIST.MF"
  inputs.file "$projectDir/build-template.properties"
  outputs.file "$projectDir/build.properties"

  dependsOn ':spotbugs:updateManifest', copyLibsForEclipse
  doLast {
    def manifestSpec = manifest {
      from "$projectDir/META-INF/MANIFEST-TEMPLATE.MF"
      attributes 'Bundle-SymbolicName': "$eclipsePluginId; singleton:=true",
                 'Bundle-Version': project.version,
                 'Bundle-ClassPath': ".,spotbugs-plugin.jar," + fileTree(dir: 'lib').collect {
                      projectDir.toPath().relativize(it.toPath()).toString().replace('\\', '/') }.join(',')
    }

    def distManifestSpec = manifest {
      from "$projectDir/META-INF/MANIFEST-TEMPLATE.MF"
      attributes 'Bundle-SymbolicName': "$eclipsePluginId; singleton:=true",
                 'Bundle-Version': project.version,
                 'Bundle-ClassPath': "spotbugs-plugin.jar," + fileTree(dir: 'lib').collect {
                        projectDir.toPath().relativize(it.toPath()).toString().replace('\\', '/') }.join(',')
    }
    // write manifests
    manifestSpec.writeTo("$projectDir/META-INF/MANIFEST.MF")
    distManifestSpec.writeTo("$projectDir/META-INF/MANIFEST-DIST.MF")

    // write build.properties
    def propsTemplate = file("$projectDir/build-template.properties")
    def props = new Properties()
    props.load(propsTemplate.newDataInputStream())
    props.setProperty('bin.includes', props.getProperty('bin.includes') + ',' +
        fileTree(dir: 'lib').collect { projectDir.toPath().relativize(it.toPath()).toString().replace('\\', '/') }.join(','))
    props.store(file('build.properties').newWriter(), null)
  }
}

tasks.named('compileJava').configure { dependsOn ':spotbugs:jar' }

// create manifest when importing to eclipse
tasks.named('eclipse').configure { dependsOn copyLibsForEclipse, updateManifest }

class FileRef implements org.gradle.plugins.ide.eclipse.model.FileReference {
    def file;
    def FileRef(File file){
        this.file = file
    }
    def File getFile(){
        return file;
    }
    def String getJarURL(){
        return "jar:" + file
    }
    def String getPath(){
        return file.toString().replace('\\', '/')
    }
    def boolean isRelativeToPathVariable(){
        return false
    }
}

eclipse.classpath.file {
    whenMerged {
        classpath ->
           classpath.entries.removeAll {
               entry -> entry.kind == 'lib'
           }
           copyLibsForEclipse
           fileTree(dir: 'lib').forEach {
                file ->
                    def rel = projectDir.toPath().relativize(java.nio.file.Paths.get(file.toString())).toFile()
                    org.gradle.plugins.ide.eclipse.model.ClasspathEntry entry =
                        new org.gradle.plugins.ide.eclipse.model.Library(new FileRef(rel))
                    classpath.entries.add(entry)
           }
    }
}

def jar = tasks.named('jar', Jar) {
  // Make sure we always update the manifest when building
  dependsOn updateManifest
  includeEmptyDirs = false
  from sourceSets.main.output
  archiveFileName = 'spotbugs-plugin.jar'
}

def distSpec = copySpec {
  from jar.map { it.outputs.files }
  from(project.projectDir) {
    include 'RELEASENOTES'
    include 'plugin.xml'
    include '.options'
    include 'OSGI-INF/l10n/*.properties'
    include '*.png'
    include 'about.*'
    include 'doc/*.*'
    include 'plugin/*.*'
    include 'icons/*.*'
    include 'lib/'
  }
  from('../spotbugs/') { // FIXME : Ugly... but those plugin are gonna die anyway...
    include 'plugin/**'
  }
  from('META-INF/MANIFEST-DIST.MF') {
    filter { line ->
      if (line.startsWith('Bundle-Version:')) {
        return "Bundle-Version: ${project.version}"
      }

      line
    }
    into 'META-INF/'
    rename {
      'MANIFEST.MF'
    }
  }
}

def distZip = tasks.register('distZip', Zip) {
  dependsOn jar
  with distSpec
  into "${eclipsePluginId}_${project.version}"
  archiveFileName = "${eclipsePluginId}_${project.version}.zip"
}

def testPluginJar = tasks.register('testPluginJar') {
  def jarFile = "$buildDir/site/eclipse/plugins/${eclipsePluginId}_${project.version}.jar"
  inputs.file jarFile
  doLast {
    def spotbugsJar = zipTree(jarFile)
            .matching { include 'lib/spotbugs.jar' }
            .singleFile
    if (!spotbugsJar.exists()) {
      throw new TaskInstantiationException('Eclipse plugin does not contain spotbugs.jar');
    } else {
      println 'Eclipse plugin contains spotbugs.jar'
    }
  }
}

def pluginJar = tasks.register('pluginJar', Zip) { // use Zip task, we already provide a manifest
  with distSpec
  dependsOn jar
  archiveFileName = "${eclipsePluginId}_${project.version}.jar"
  destinationDirectory = file("${buildDir}/site/eclipse/plugins/")
  finalizedBy testPluginJar
}

def pluginCandidateJar = tasks.register('pluginCandidateJar', Copy) {
  dependsOn pluginJar
  from pluginJar.map { it.outputs.files }
  into "${buildDir}/site/eclipse-candidate/plugins/"
}

def pluginDailyJar = tasks.register('pluginDailyJar', Copy) {
  dependsOn pluginJar
  from pluginJar.map { it.outputs.files }
  into "${buildDir}/site/eclipse-daily/plugins/"
}

def pluginStableLatestJar = tasks.register('pluginStableLatestJar', Copy) {
  dependsOn pluginJar
  from pluginJar.map { it.outputs.files }
  into "${buildDir}/site/eclipse-stable-latest/plugins/"
}

def siteFilterTokens = [
  'PLUGIN_ID': eclipsePluginId,
  'PLUGIN_VERSION':"${project.version}".toString(),
  'FEATURE_ID': eclipsePluginId,
  'FEATURE_VERSION':"${project.version}".toString()
]

def featureJar = tasks.register('featureJar', Zip) {
  archiveFileName = "${eclipsePluginId}_${project.version}.jar"
  entryCompression = ZipEntryCompression.STORED // no compression, this is a jar with no manifest
  from('plugin_feature.xml') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'feature.xml' }
  }
  from('feature_p2.inf') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'p2.inf' }
  }
  destinationDirectory = file("${buildDir}/site/eclipse/features/")
}

def featureCandidateJar = tasks.register('featureCandidateJar', Zip) {
  archiveFileName = "${eclipsePluginId}_${project.version}.jar"
  entryCompression = ZipEntryCompression.STORED // no compression, this is a jar with no manifest
  from('plugin_feature-candidate.xml') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'feature.xml' }
  }
  from('feature_p2.inf') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'p2.inf' }
  }
  destinationDirectory = file("${buildDir}/site/eclipse-candidate/features/")
}

def featureDailyJar = tasks.register('featureDailyJar', Zip) {
  archiveFileName = "${eclipsePluginId}_${project.version}.jar"
  entryCompression = ZipEntryCompression.STORED // no compression, this is a jar with no manifest
  from('plugin_feature-daily.xml') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'feature.xml' }
  }
  from('feature_p2.inf') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'p2.inf' }
  }
  destinationDirectory = file("${buildDir}/site/eclipse-daily/features/")
}

def featureStableLatestJar = tasks.register('featureStableLatestJar', Zip) {
  archiveFileName = "${eclipsePluginId}_${project.version}.jar"
  entryCompression = ZipEntryCompression.STORED // no compression, this is a jar with no manifest
  from('plugin_feature-stable_latest.xml') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'feature.xml' }
  }
  from('feature_p2.inf') {
    filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
    rename { 'p2.inf' }
  }
  destinationDirectory = file("${buildDir}/site/eclipse-stable-latest/features/")
}

def siteHtml = tasks.register('siteHtml', Copy) {
  filter(tokens:[
    'URL': 'https://spotbugs.github.io/eclipse/'
  ] + siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site.html'
  destinationDir = file("${buildDir}/site/eclipse")
  rename { 'index.html' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteCandidateHtml = tasks.register('siteCandidateHtml', Copy) {
  filter(tokens:[
    'URL': 'https://spotbugs.github.io/eclipse-candidate/'
  ] + siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site.html'
  destinationDir = file("${buildDir}/site/eclipse-candidate")
  rename { 'index.html' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteDailyHtml = tasks.register('siteDailyHtml', Copy) {
  filter(tokens:[
    'URL': 'https://spotbugs.github.io/eclipse-latest/'
  ] + siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site.html'
  destinationDir = file("${buildDir}/site/eclipse-daily")
  rename { 'index.html' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteStableLatestHtml = tasks.register('siteStableLatestHtml', Copy) {
  filter(tokens:[
    'URL': 'https://spotbugs.github.io/eclipse-stable-latest/'
  ] + siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site.html'
  destinationDir = file("${buildDir}/site/eclipse-stable-latest")
  rename { 'index.html' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteXml = tasks.register('siteXml', Copy) {
  filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site.xml'
  destinationDir = file("${buildDir}/site/eclipse")
  rename { 'site.xml' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteCandidateXml = tasks.register('siteCandidateXml', Copy) {
  filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site-candidate.xml'
  destinationDir = file("${buildDir}/site/eclipse-candidate")
  rename { 'site.xml' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteDailyXml = tasks.register('siteDailyXml', Copy) {
  filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site-daily.xml'
  destinationDir = file("${buildDir}/site/eclipse-daily")
  rename { 'site.xml' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

def siteStableLatestXml = tasks.register('siteStableLatestXml', Copy) {
  filter(tokens:siteFilterTokens, org.apache.tools.ant.filters.ReplaceTokens)
  from 'plugin_site-stable_latest.xml'
  destinationDir = file("${buildDir}/site/eclipse-stable-latest")
  rename { 'site.xml' }
  outputs.upToDateWhen {
    // even if we have generated file, we should rerun this task to overwrite it.
    false
  }
}

// sign all .jar file under specified dir
ext.signJar = { File dir ->
  def keystorepass = project.hasProperty('keystorepass') ? keystorepass : '';
  if (keystorepass.isEmpty()) {
    print 'to sign eclipse plugins, set "keystorepass" project property'
    return
  }

  dir.traverse(type: FILES, nameFilter: ~/.*\.jar$/) {
    def relativePath = rootDir.toPath().relativize( it.toPath() )
    println "signing ${relativePath}"
    ant.signjar(
        destDir: it.parentFile,
        jar: it,
        alias: 'eclipse-plugin',
        keystore: "$rootDir/spotbugs.jks",
        storepass: keystorepass,
        tsaurl: 'http://timestamp.digicert.com',
        verbose: true
    )
  }
}

def confirmEclipse = tasks.register('confirmEclipse') {
  doFirst {
    if (eclipseExecutable == null || !eclipseExecutable.exists()) {
      throw new GradleScriptException("No eclipse found in local")
    }
  }
}

def generateP2Metadata = tasks.register('generateP2Metadata', Exec) {
  doFirst {
    project.delete "${buildDir}/site/eclipse/artifacts.xml"
    project.delete "${buildDir}/site/eclipse/content.xml"
    signJar(file("${buildDir}/site/eclipse"))
  }
  inputs.file 'local.properties'
  dependsOn confirmEclipse, pluginJar, featureJar, siteXml, siteHtml
  commandLine "${eclipseExecutable}", '-nosplash',
    '-application', 'org.eclipse.equinox.p2.publisher.UpdateSitePublisher',
    '-metadataRepository', "file:${buildDir}/site/eclipse", // TODO : May not work on Windows
    '-artifactRepository', "file:${buildDir}/site/eclipse", // TODO : May not work on Windows
    '-source', "${buildDir}/site/eclipse"
}

def generateCandidateP2Metadata = tasks.register('generateCandidateP2Metadata', Exec) {
  doFirst {
    project.delete "${buildDir}/site/eclipse-candidate/artifacts.xml"
    project.delete "${buildDir}/site/eclipse-candidate/content.xml"
    signJar(file("${buildDir}/site/eclipse-candidate"))
  }
  inputs.file 'local.properties'
  dependsOn confirmEclipse, pluginCandidateJar, featureCandidateJar, siteCandidateXml, siteCandidateHtml
  commandLine "${eclipseExecutable}", '-nosplash',
    '-application', 'org.eclipse.equinox.p2.publisher.UpdateSitePublisher',
    '-metadataRepository', "file:${buildDir}/site/eclipse-candidate", // TODO : May not work on Windows
    '-artifactRepository', "file:${buildDir}/site/eclipse-candidate", // TODO : May not work on Windows
    '-source', "${buildDir}/site/eclipse-candidate"
}

def generateP2MetadataDaily = tasks.register('generateP2MetadataDaily', Exec) {
  doFirst {
    project.delete "${buildDir}/site/eclipse-daily/artifacts.xml"
    project.delete "${buildDir}/site/eclipse-daily/content.xml"
    signJar(file("${buildDir}/site/eclipse-daily"))
  }
  inputs.file 'local.properties'
  dependsOn confirmEclipse, pluginDailyJar, featureDailyJar, siteDailyXml, siteDailyHtml
  commandLine "${eclipseExecutable}", '-nosplash',
    '-application', 'org.eclipse.equinox.p2.publisher.UpdateSitePublisher',
    '-metadataRepository', "file:${buildDir}/site/eclipse-daily", // TODO : May not work on Windows
    '-artifactRepository', "file:${buildDir}/site/eclipse-daily", // TODO : May not work on Windows
    '-source', "${buildDir}/site/eclipse-daily"
}

def generateP2MetadataStableLatest = tasks.register('generateP2MetadataStableLatest', Exec) {
  doFirst {
    project.delete "${buildDir}/site/eclipse-stable-latest/artifacts.xml"
    project.delete "${buildDir}/site/eclipse-stable-latest/content.xml"
    signJar(file("${buildDir}/site/eclipse-stable-latest"))
  }
  inputs.file 'local.properties'
  dependsOn confirmEclipse, pluginStableLatestJar, featureStableLatestJar, siteStableLatestXml, siteStableLatestHtml
  commandLine "${eclipseExecutable}", '-nosplash',
    '-application', 'org.eclipse.equinox.p2.publisher.UpdateSitePublisher',
    '-metadataRepository', "file:${buildDir}/site/eclipse-stable-latest", // TODO : May not work on Windows
    '-artifactRepository', "file:${buildDir}/site/eclipse-stable-latest", // TODO : May not work on Windows
    '-source', "${buildDir}/site/eclipse-stable-latest"
}

def eclipseSite = tasks.register('eclipseSite') {
  dependsOn generateP2Metadata, generateCandidateP2Metadata, generateP2MetadataDaily, generateP2MetadataStableLatest
}

// create zip file to upload to GitHub release page
def eclipseSiteZip = tasks.register('eclipseSiteZip', Zip) {
  dependsOn eclipseSite
  from("${buildDir}/site/eclipse")
  archiveFileName = "eclipsePlugin.zip"
}

if (eclipseExecutable == null) {
  println "Create local.properties to build eclipse site"
} else {
  tasks.named('assemble').configure { dependsOn eclipseSiteZip }
}

spotbugs {
  ignoreFailures = true
}