build.gradle

plugins {
	// osgi
	id "org.jruyi.osgibnd" version "0.4.0"
	// code formatting
	id "com.diffplug.gradle.spotless" version "1.3.1"
	// bintray uploading
	id "com.jfrog.bintray" version "1.3.1"
	// for downloading JRE6
	id "de.undercouch.download" version "2.0.0"
}

repositories {
	mavenCentral()
}

//////////
// JAVA //
//////////
apply plugin: 'java'
sourceSets {
	main { java {
			srcDir 'src'
	} }
	test { java {
			srcDir 'test'
	} }
}
sourceCompatibility = VER_JAVA
targetCompatibility = VER_JAVA

dependencies {
	testCompile "junit:junit:${VER_JUNIT}"
}

processResources {
	from ('src') {
		exclude '**/*.java'
	}
}

////////////////////
// MATLAB TESTING //
////////////////////
// standard `gradlew test` can't handle tests which require a MATLAB installation
test {
	// test
	useJUnit {
		excludeCategories 'matlabcontrol.MatlabRequired$Interactive'
		excludeCategories 'matlabcontrol.MatlabRequired$Headless'
	}
}

task testMatlabHeadless(type: Test) {
	useJUnit {
		includeCategories 'matlabcontrol.MatlabRequired$Headless'
	}
}
task testMatlabInteractive(type: Test) {
	useJUnit {
		includeCategories 'matlabcontrol.MatlabRequired$Interactive'
	}
}
task testMatlabAll(dependsOn: [test, testMatlabHeadless, testMatlabInteractive])

//////////
// OSGI //
//////////

// delete the old manifest to ensure there's no caching or merging going on
jar.doFirst {
	project.file('META-INF/MANIFEST.MF').delete()
}

jar.manifest {
	attributes (
		'Export-Package': 'matlabcontrol.*,!matlabcontrol.internal.*,!matlabcontrol.demo.*',
		'Bundle-SymbolicName': "${project.group}.${project.name}",
		'Bundle-Vendor': 'DiffPlug',
		'Bundle-DocURL': "https://github.com/${project.org}/${project.name}",
		'Bundle-License': "https://github.com/${project.org}/${project.name}/blob/v${project.version}/LICENSE",
		'Import-Package': '!com.mathworks.jmi',
		'Main-Class': 'matlabcontrol.demo.DemoMain',
		'-includeresource': "matlabcontrol=${sourceSets.main.output.classesDir}/matlabcontrol,${sourceSets.main.output.resourcesDir}",
		'-removeheaders': 'Bnd-LastModified,Bundle-Name,Created-By,Tool,Private-Package',
		'-savemanifest': project.file('META-INF/MANIFEST.MF'),
	)
}

// manifests are only generated when the java files change - not if manifest properties change
// this task forces the manifests to regenerate
task refreshManifest(dependsOn: jar)
gradle.taskGraph.whenReady { taskGraph ->
	if (taskGraph.hasTask(refreshManifest)) {
		jar.outputs.upToDateWhen { false }
	}
}

////////////
// JAVA 6 //
////////////

// matlabcontrol requires at least Java 1.6,
// but older MATLABs run on even older versions

// URL for downloading the JRE6
// others available here, OS doesn't matter: https://github.com/alexkasko/openjdk-unofficial-builds#openjdk-6-build-30
def JDK6_URL = 'https://bitbucket.org/alexkasko/openjdk-unofficial-builds/downloads/openjdk-1.6.0-unofficial-b30-windows-i586-image.zip'
def JDK6_SHA_256 = '8a119a8c9b2ecc48e8457738f57b251e6265b2c0fb232de0ff6fddce0f127045'
// place where the JRE6 will end up
def JDK6_DIR = "${buildDir}/jdk"
def JDK6_DST = "${JDK6_DIR}/jdk.zip"
def JRE6_HOME = "${buildDir}/jdk/openjdk-1.6.0-unofficial-b30-windows-i586-image/jre"

import de.undercouch.gradle.tasks.download.Download;
import de.undercouch.gradle.tasks.download.Verify;

task downloadJRE6(type: Download) {
	src JDK6_URL
	dest JDK6_DST
	overwrite false
}

task verifyJRE6(dependsOn: downloadJRE6, type: Verify) {
	src downloadJRE6.dest
	algorithm 'SHA-256'
	checksum JDK6_SHA_256
}

task unzipJRE6(dependsOn: verifyJRE6, type: Copy) {
	from zipTree(downloadJRE6.dest)
	into JDK6_DIR
}

// Best bet is to stay at 1.6
sourceCompatibility = 1.6
targetCompatibility = 1.6
def sep = System.getProperty('path.separator')
def bootClasspathStr = "${JRE6_HOME}/lib/rt.jar${sep}${JRE6_HOME}/lib/jsse.jar"
project.tasks.withType(AbstractCompile, { AbstractCompile ac ->
	ac.options.bootClasspath = bootClasspathStr // options is always there but not defined on AbstractCompile so going to hit it anyway
	ac.dependsOn(unzipJRE6)
})

/////////////
// ECLIPSE //
/////////////
apply plugin: 'eclipse'
eclipse {
	project {
		natures 'org.eclipse.pde.PluginNature'
		natures 'org.eclipse.jdt.core.javanature'

		buildCommand 'org.eclipse.jdt.core.javabuilder'
		buildCommand 'org.eclipse.pde.ManifestBuilder'
		buildCommand 'org.eclipse.pde.SchemaBuilder'
	}
	classpath {
		downloadSources true
		downloadJavadoc true
	}
	jdt {
		sourceCompatibility VER_JAVA
		targetCompatibility VER_JAVA
	}
}
// always create fresh projects
tasks.eclipse.dependsOn(cleanEclipse)

////////////
// FORMAT //
////////////
spotless {
	java {
		licenseHeaderFile	'spotless.license.java'			// License header file
		importOrderFile		'spotless.importorder'			// An import ordering file, exported from Eclipse
		eclipseFormatFile	'spotless.eclipseformat.xml'	// XML file dumped out by the Eclipse formatter
		// Eclipse formatter puts excess whitespace after lambda blocks
		//    funcThatTakesLambdas(x -> {} , y -> {} )	// what Eclipse does
		//    funcThatTakesLambdas(x -> {}, y -> {})	// what I wish Eclipse did
		custom 'Lambda fix', { it.replace('} )', '})').replace('} ,', '},') }
	}
	format 'misc', {
		target '**/.gitignore', '**/*.gradle', '**/*.md', '**/*.sh'
		indentWithTabs()
		trimTrailingWhitespace()
		endWithNewline()
	}
	freshmark {}
}

//////////////
// FINDBUGS //
//////////////
apply plugin: 'findbugs'
findbugs {
	toolVersion = VER_FINDBUGS
	sourceSets = [sourceSets.main]	// don't check the test code
	ignoreFailures = false 	// bug free or it doesn't ship!
	reportsDir = file('build/findbugs')
	effort = 'max'			// min|default|max
	reportLevel = 'medium'	// low|medium|high (low = sensitive to even minor mistakes)
	omitVisitors = []		// bugs that we want to ignore
}
// HTML instead of XML
tasks.withType(FindBugs) {
	reports {
		xml.enabled = false
		html.enabled = true
	}
}
// we'll want the findbugs annotations (they don't have a 3.0.1 version)
dependencies {
	compile 'com.google.code.findbugs:annotations:3.0.0'
	compile 'com.google.code.findbugs:jsr305:3.0.0'
}

///////////
// MAVEN //
///////////
apply plugin: 'maven-publish'

// the package of the jmi stub (which we're going to leave out of all the jars we make)
def JMI_STUB = 'com/mathworks/jmi/**'

// make a source jar
task sourcesJar(type: Jar) {
	classifier = 'sources'
	from sourceSets.main.allJava
	exclude(JMI_STUB)
}

// Where it's possible to name parameters and methods clearly enough
// that javadoc is not necessary, why make the code bigger?
//
// Thus, no javadoc warnings.
def makeLink = { url, text -> "<a href=\"${url}\" style=\"text-transform: none;\">${text}</a>" }
def javadocInfo = '<h2>' + makeLink("https://github.com/${org}/${name}", "${group}:${name}:${version}") +
' by ' + makeLink('http://www.diffplug.com', 'DiffPlug') + '</h2>'
javadoc {
	options.addStringOption('Xdoclint:none', '-quiet')
	options.header javadocInfo
	options.footer javadocInfo
	options.links('https://docs.oracle.com/javase/6/docs/api/')
}

task javadocJar(type: Jar, dependsOn: javadoc) {
	classifier = 'javadoc'
	from javadoc.destinationDir
}

////////////////
// PUBLISHING //
////////////////
def isSnapshot = project.version.endsWith('-SNAPSHOT')
// pulls the credentials from either the environment variable or gradle.properties
def cred = {
	if (System.env[it] != null) {
		return System.env[it]
	} else if (project.hasProperty(it)) {
		return project[it]
	} else {
		return 'unknown_' + it
	}
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			from components.java
			artifact sourcesJar
			artifact javadocJar
			pom.withXml {
				// findbugs annotations should have scope "provided"
				asNode().dependencies.'*'.findAll() { it.groupId.text() == 'com.google.code.findbugs' }.each() { it.scope*.value = 'provided' }
				// add MavenCentral requirements to the POM
				asNode().children().last() + {
					resolveStrategy = Closure.DELEGATE_FIRST
					name project.name
					description project.description
					url "https://github.com/${project.org}/${project.name}"
					scm {
						url "https://github.com/${project.org}/${project.name}"
						connection "scm:git:git://github.com/${project.org}/${project.name}"
						developerConnection "scm:git:ssh:git@github.com/${project.org}/${project.name}"
					}
					licenses {
						license {
							name 'New BSD License'
							url 'https://github.com/diffplug/matconsolectl/blob/v4.4.0/LICENSE'
							distribution 'repo'
						}
					}
					developers {
						developer {
							id 'nedtwigg'
							name 'Ned Twigg'
							email 'ned.twigg@diffplug.com'
						}
					}
				}
			}
		}
	}
	if (isSnapshot) {
		// upload snapshots to oss.sonatype.org
		repositories { maven {
			url = 'https://oss.sonatype.org/content/repositories/snapshots'
			credentials {
				username = cred('nexus_user')
				password = cred('nexus_pass')
			}
		} }
	}
}

if (!isSnapshot) {
	// upload releases to bintray and then mavenCentral
	bintray {
		user = cred('bintray_user')
		key = cred('bintray_pass')
		publications = ['mavenJava']
		publish = true
		pkg {
			repo = 'opensource'
			name = project.name
			userOrg = project.org
			version {
				name = project.version
				mavenCentralSync {
					user = cred('nexus_user')
					password = cred('nexus_pass')
				}
			}
		}
	}

	publish.dependsOn(bintrayUpload)
	bintrayUpload.dependsOn(['generatePomFileForMavenJavaPublication', jar, sourcesJar, javadocJar])
}

// helps external scripts detect version
task printVersion << {
	println version
}