build.gradle

// Plugin declaration

import org.apache.tools.ant.taskdefs.condition.Os

buildscript {
	apply from: 'https://dbis-owncloud.uibk.ac.at/index.php/s/VOI0J20KJtOrFA9/download?path=%2F&files=changelog.gradle'
	apply from: 'https://dbis-owncloud.uibk.ac.at/index.php/s/VOI0J20KJtOrFA9/download?path=%2F&files=checkstyle.gradle'
}

plugins {
	id 'com.github.johnrengelman.shadow' version '2.0.1'
	id 'com.kageiit.url-cache' version '1.0.0'
	id 'com.moowork.grunt' version '1.1.1'
	id 'com.moowork.node' version '1.1.1'
	id 'de.ploing.scmversion' version '0.6.6'
	id 'org.akhikhl.gretty' version '1.4.2'
	id 'org.asciidoctor.convert' version '1.5.3'
}

apply plugin: 'eclipse-wtp'
apply plugin: 'findbugs'
apply plugin: 'jacoco'
apply plugin: 'java'
apply plugin: 'jdepend'
apply plugin: 'maven-publish'
apply plugin: 'war'

// Basic settings

group = 'at.uibk.dbis'
sourceCompatibility=JavaVersion.VERSION_1_8
targetCompatibility=JavaVersion.VERSION_1_8

description = 'PhD project of Nikolaus Krismer (IsoMap WebUI)'

scmversion {
	releaseTagPattern = 'v([0-9.]*)'
}

ext {
	// The selenium drivers we want to use
	// drivers = ["firefox", "chrome", "phantomJS"]
	// drivers = ["chrome", "phantomJS"]
	drivers = ["firefox"]

	versionALPN = '8+'
	versionChromeDriver = '2.31'
	versionCommonsJCS = '+'
	versionCommonsMath = '+'
	versionConfigBuilder = '1+'
	versionEqualsverifier = '2+'
	versionFindbugs = '+'
	versionGeckoDriver = 'v0.18.0'
	versionGeoserverManager = '+'
	versionGeotools = '+'
	versionGhostDriver = '2.1.0'
	versionHttpClient = '+'
	versionIsochrone = project.version
	versionJAI = '+'
	versionJackson = '2.4+'
	versionJacksonGeojson = '1.5'
	versionJacoco = '0.7.9+'
	versionJersey = '2.25'
	versionJetty = '9+'
	versionLog4j = '2+'
	versionNpm = '5.3.0'
	versionNodeJs = '8.3.0'
	versionPhantomJs = '2.1.1'
	versionSelenium = '3.+'
	versionServletApi = '3.1.0'
	versionTestNG = '6+'
	versionTomcatWebsocket = '8+'
	versionWebsocketApi = '1.0'
}

apply from: "seleniumDriverDownloads.gradle"

gradle.taskGraph.whenReady {taskGraph ->
	println ((project.version.endsWith('-SNAPSHOT')) ? "Building SNAPSHOT version $version\n" : "Building RELEASE version $version\n");
}

// Repositories, Configurations, Dependencies and SourceSets setup

repositories {
	mavenCentral()
	jcenter()
	maven {
		// repo for latest version of jai-core (javax.media.jai:com.springsource.javax.media.jai.core:+)
		// also see https://issues.gradle.org/browse/GRADLE-2395
		url 'https://repo.gradle.org/gradle/plugins-releases'
	}
	maven {
		// repo for latest version of geotools
		url 'http://download.osgeo.org/webdav/geotools'
	}
	maven {
		// repo for slim jar dependencies (used by geotools)
        url 'http://mvn.slimjars.com'
    }
    maven {
		// for ghostdriver version >= 2.x
		url 'https://jitpack.io'
	}
	maven {
		// repo for geo-manager
		url 'http://maven.geo-solutions.it'
	}
	repositoryGroup.split(',').each{g ->
		// repo(s) for isochrone
		maven { url g.trim() }
	}
}

sourceSets {
	jetty {
		java {
			compileClasspath += main.output
			runtimeClasspath += main.output
		}
	}
	integration {
		java {
			compileClasspath += main.output
			runtimeClasspath += main.output
		}
	}
}

configurations {
	jettyCompile.extendsFrom compile
	jettyRuntime.extendsFrom runtime

	integrationCompile.extendsFrom compile
	integrationRuntime.extendsFrom runtime
}

dependencies {
	// use same version of "isochrone" dependency (as for this "isochrone-web" project)
	testCompile (group: 'at.uibk.dbis', name: 'isochrone', version: versionIsochrone, changing: true) {
		artifact {
			name = 'isochrone'
			classifier = 'testJar'
			type = 'jar'
		}
	}
	compile (group: 'at.uibk.dbis', name: 'isochrone', version: versionIsochrone, changing: true) {
		artifact {
			name = 'isochrone'
			type = 'jar'
		}
	}

	compile "de.grundid.opendatalab:geojson-jackson:${versionJacksonGeojson}"
	compile "com.fasterxml.jackson.core:jackson-core:${versionJackson}"
	compile "com.fasterxml.jackson.core:jackson-databind:${versionJackson}"
	compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${versionJackson}"
	compile "com.google.code.findbugs:annotations:${versionFindbugs}"
	compile "com.tngtech.java:config-builder:${versionConfigBuilder}"
	compile ("it.geosolutions:geoserver-manager:${versionGeoserverManager}") { exclude module: 'jcl-over-slf4j' }
	compile "javax.media.jai:com.springsource.javax.media.jai.core:${versionJAI}"
	compile "org.apache.commons:commons-jcs-core:${versionCommonsJCS}"
	compile "org.apache.commons:commons-math3:${versionCommonsMath}"
	compile "org.apache.logging.log4j:log4j-api:${versionLog4j}"
	compile ("org.geotools:gt-api:${versionGeotools}") { exclude module: 'jai_core' }
	compile ("org.geotools:gt-epsg-hsql:${versionGeotools}") { exclude module: 'jai_core' }
	compile "org.glassfish.jersey.containers:jersey-container-servlet:${versionJersey}"
	compile "org.glassfish.jersey.media:jersey-media-json-jackson:${versionJersey}"

	// provided dependencies (by jetty, tomcat or any other servlet container)

	providedCompile "javax.servlet:javax.servlet-api:${versionServletApi}"
	providedCompile "javax.websocket:javax.websocket-api:${versionWebsocketApi}"
	// adding tomcat-embed-websocket for integration testing (so gretty is able to allow websocket connections)
	providedCompile ("org.apache.tomcat.embed:tomcat-embed-websocket:${versionTomcatWebsocket}") { exclude module: 'tomcat-embed-core' }

	// dependencies for logging
	runtime "org.apache.logging.log4j:log4j-core:${versionLog4j}"
	runtime "org.apache.logging.log4j:log4j-jcl:${versionLog4j}"
	runtime "org.apache.logging.log4j:log4j-jul:${versionLog4j}"
	runtime "org.apache.logging.log4j:log4j-slf4j-impl:${versionLog4j}"
	runtime "org.apache.logging.log4j:log4j-web:${versionLog4j}"

	integrationCompile("com.github.detro:ghostdriver:${versionGhostDriver}") {
		// phantomjs driver pulls in a different selenium version
		transitive = false
	}
	integrationCompile "com.google.code.findbugs:annotations:${versionFindbugs}"
	integrationCompile "org.testng:testng:${versionTestNG}"
	integrationCompile "org.seleniumhq.selenium:selenium-chrome-driver:${versionSelenium}"
	integrationCompile "org.seleniumhq.selenium:selenium-firefox-driver:${versionSelenium}"
	integrationCompile "org.seleniumhq.selenium:selenium-support:${versionSelenium}"

	jettyCompile "org.eclipse.jetty.aggregate:jetty-all:${versionJetty}"
	jettyCompile "org.eclipse.jetty:jetty-alpn-server:${versionJetty}"
	//jettyCompile "org.eclipse.jetty.alpn:alpn-api:${versionALPN}"
	jettyCompile "org.mortbay.jetty.alpn:alpn-boot:${versionALPN}"

	testCompile "com.fasterxml.jackson.module:jackson-module-jsonSchema:${versionJackson}"
	testCompile "nl.jqno.equalsverifier:equalsverifier:${versionEqualsverifier}"
	testCompile "org.apache.httpcomponents:httpclient:${versionHttpClient}"
//	testCompile 'org.apache.jmeter:ApacheJMeter:2.+'
	testCompile "org.glassfish.jersey.core:jersey-client:${versionJersey}"
	testCompile "org.testng:testng:${versionTestNG}"
}

// Detailled settings (tasks, task configuration, ...)

tasks.withType(JavaCompile) {
	// workaround for http://issues.gradle.org/browse/GRADLE-1230
	doFirst { println '' }

	// adds support for compiler warnings generation
	options.compilerArgs << '-Xlint:all,-processing'
}

asciidoctor {
	backend = 'html5'
	sourceDir = file('doc')
	outputDir = file("$buildDir/docs/asciidoctor")
}

checkstyle {
	ignoreFailures = true
	showViolations = false
}

eclipse {
	classpath {
		plusConfigurations += [configurations.jettyCompile, configurations.integrationCompile]

		file {
			// See: http://gradle.1045684.n5.nabble.com/Gradle-s-Eclipse-DSL-and-resolving-dependencies-to-workspace-projects-td4856525.html
			// See: http://stackoverflow.com/questions/17567312/missing-project-dependencies-in-eclipse
			// See: https://github.com/spring-projects/spring-webflow/blob/master/ide.gradle
			// See: http://issues.gradle.org/browse/GRADLE-1116
//			beforeMerged { cp ->
//				def toBeRemoved = cp.entries.findAll { it instanceof Library && ((Library) it).library.path.contains('at.uibk.dbis') }
//				cp.entries -= toBeRemoved
//			}

			// See: http://forums.gradle.org/gradle/topics/eclipse_wtp_deploys_testcode_to_server_example_provided
			// Sets output folders for compiled classes and resources... otherwise test classes/resources would be deployed to wtp server
			whenMerged { cp ->
				cp.entries.findAll { it.path.startsWith('src/jetty/') }*.output = 'bin-jetty'
				cp.entries.findAll { it.path.startsWith('src/main/') }*.output = 'bin'
				cp.entries.findAll { it.path.startsWith('src/test/') }*.output = 'bin-test'
				cp.entries.findAll { it.path.startsWith('src/integration/') }*.output = 'bin-integration'
				// Sets JavaSE as jdk version used (instead of version directly)
				cp.entries.findAll { it.path.contains('JRE_CONTAINER') }.each {
					it.path += '/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-' + sourceCompatibility
				}
			}

			// See: http://stackoverflow.com/questions/12836089/why-is-eclipse-not-attaching-3rd-party-libs-source-files-to-a-wtp-faceted-gradle
			// Changes eclipse classpath entries; otherwise no sources for 3rd party jars are shown
			withXml { xml ->
				def node = xml.asNode()
				node.remove( node.find { it.@path == 'org.eclipse.jst.j2ee.internal.web.container' } )
				node.appendNode( 'classpathentry', [ kind: 'con', path: 'org.eclipse.jst.j2ee.internal.web.container', exported: 'true'])
			}
		}
	}

	project {
		buildCommand 'net.sf.eclipsecs.core.CheckstyleBuilder'

		file {
			withXml { xmlProvider ->
				Node project = xmlProvider.asNode()
				Node filteredResources = project.appendNode('filteredResources');

				Node filterGradle = filteredResources.appendNode('filter')
				filterGradle.appendNode('id', 1392635165065)
				filterGradle.appendNode('name', '')
				filterGradle.appendNode('type', 10)
				Node matcherGradle = filterGradle.appendNode('matcher')
				matcherGradle.appendNode('id', 'org.eclipse.ui.ide.multiFilter')
				matcherGradle.appendNode('arguments', '1.0-name-matches-false-false-.gradle')

				Node filterNodeModules = filteredResources.appendNode('filter')
				filterNodeModules.appendNode('id', 1396275587572)
				filterNodeModules.appendNode('name', '')
				filterNodeModules.appendNode('type', 10)
				Node matcherNodeModules = filterNodeModules.appendNode('matcher')
				matcherNodeModules.appendNode('id', 'org.eclipse.ui.ide.multiFilter')
				matcherNodeModules.appendNode('arguments', '1.0-name-matches-false-false-node_modules')
			}
		}

		natures = [
			'net.sf.eclipsecs.core.CheckstyleNature',
			'org.springsource.ide.eclipse.gradle.core.nature',
			'org.eclipse.jem.workbench.JavaEMFNature',
			'org.eclipse.wst.common.modulecore.ModuleCoreNature',
			'org.eclipse.wst.common.project.facet.core.nature',
			'org.eclipse.jdt.core.javanature',
			'org.eclipse.wst.jsdt.core.jsNature'
		]

//		referencedProjects = [
//			'isochrone'
//		] as Set
	}

	wtp {
		component {
			contextPath = '/isochrone'
			deployName = 'isochrone'
			resource sourcePath: 'src/main/webapp', deployPath: '/'
		}

		facet {
			facet name: 'jst.web', version: '3.1'
			facet name: 'jst.java', version: sourceCompatibility
			facet name: 'wst.jsdt.web', version: '1.0'
		}
	}
}

findbugs {
	effort = 'max'
	ignoreFailures = true
	reportLevel = 'low'
	toolVersion = versionFindbugs
}

gretty {
	httpPort = 8090
	servicePort = 9010
	statusPort = 9011

	contextPath = '/isochrone'
	integrationTestTask = 'testIntegration'
	inplaceMode = 'hard'
	scanInterval = 0
	servletContainer = 'tomcat8'

	afterEvaluate {
		tasks.jettyBeforeIntegrationTest.jacoco {
			append = false
			destinationFile = new File(project.buildDir, 'jacoco/integrationTest_server.exec')
		}
	}
}

grunt {
	colors = true
}

jacoco {
	toolVersion = versionJacoco
}

javadoc {
	failOnError = false
}

node {
	download = true
	version = versionNodeJs
	npmVersion = versionNpm
}

npm_install {
  args = ['--no-optional']
}

tasks.withType(NpmTask) {
	args += ['--loglevel', 'warn']
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			artifact javadocJar
			artifact jettyWar
			artifact sourcesJar
			artifact shadowJar
			artifact war
			artifact testWar
		}
	}

	repositories {
		maven {
			credentials {
				username repositoryUsername
				password repositoryPassword
			}

			if (project.version.endsWith('-SNAPSHOT')) {
				url repositorySnapshots
			} else {
				url repositoryReleases
			}
		}
	}
}

shadowJar {
	mergeServiceFiles()

	exclude '**/*-test.xml'
}

test {
	outputs.upToDateWhen { false }
	useTestNG {
		useDefaultListeners = true
	}

	testLogging {
		events 'started', 'passed', 'skipped', 'failed'
	}

	systemProperty 'log4j.configurationFile', "file:$projectDir/src/test/resources/log4j2-test.xml"
	ignoreFailures = true
	minHeapSize = '128m'
	maxHeapSize = '1024m'

	// turn off Gradle's HTML report to avoid replacing the reports generated by TestNG library:
	reports.html.enabled = false
	finalizedBy "cleanTestResults"
}

war {
	description = 'Build the war file for release (using the backend available at localhost)'

	rootSpec.exclude '**/*-test.xml'

	// exclude files that webpack compiles to folder "dist/"
	exclude("css")
	exclude("images")
	exclude("js")
	exclude("index_devel.html")
	exclude("index_template.html")
}

// Selenium test tasks

drivers.each { driver ->
	task "testIntegration${driver.capitalize()}"(type: Test) {
		outputs.upToDateWhen { false }

		// Download chromeDriver / phantomJsDriver
		if ("$driver" == "chrome") {
			dependsOn unzipChromeDriver

			def chromedriverFilename = Os.isFamily(Os.FAMILY_WINDOWS) ? "chromedriver.exe" : "chromedriver"
			systemProperty "webdriver.chrome.driver", new File(unzipChromeDriver.outputs.files.singleFile, chromedriverFilename).absolutePath
		} else if ("$driver" == "firefox") {
			dependsOn unzipGeckoDriver

			def geckodriverFilename = Os.isFamily(Os.FAMILY_WINDOWS) ? "geckodriver.exe" : "geckodriver"
			systemProperty "webdriver.gecko.driver", new File(unzipGeckoDriver.outputs.files.singleFile, geckodriverFilename).absolutePath
		} else if ("$driver" == "phantomJS") {
			dependsOn unzipPhantomJS

			def phantomJsFilename = Os.isFamily(Os.FAMILY_WINDOWS) ? "phantomjs.exe" : "bin/phantomjs"
			systemProperty "phantomjs.binary.path", new File(unzipPhantomJS.outputs.files.singleFile, phantomJsFilename).absolutePath
		}

		useTestNG {
			useDefaultListeners = true
			outputDirectory = file("$buildDir/reports/integration/${driver}")
		}

		testLogging {
			events 'started', 'passed', 'skipped', 'failed'
		}

		jacoco {
			append = false
			destinationFile = new File(project.buildDir, "jacoco/integrationTest_client_${driver}.exec")
		}

		classpath = sourceSets.integration.runtimeClasspath
		testClassesDirs = sourceSets.integration.output.classesDirs

		ignoreFailures = true
		minHeapSize = '128m'
		maxHeapSize = '1024m'
		systemProperty "selenium.driver", driver

		// turn off Gradle's HTML report to avoid replacing the reports generated by TestNG library:
		reports.html.enabled = false
	}
}

// Custom task definitions

task checkJavascript(dependsOn: grunt_check)

task cleanGeneratedBuildFiles(type: Delete) {
	delete "$buildDir/dependency-cache"
	delete "$buildDir/tmp"
	delete "$buildDir/webapp"
	delete '.gradle'
}

task cleanJavascript(type: Delete) {
	delete 'src/main/webapp/dist'
	delete 'src/main/webapp/index.html'
	delete 'src/main/webapp/index_devel.html'
	delete 'src/main/webapp/index_noMin.html'
}

task cleanNodeModules(type: Delete) {
	delete files('node_modules')
}

task cleanTestResults(type: Delete) {
	// We only need the test reports... not the binary results
	delete project.testResultsDir
}

task compileJavascript(type: GruntTask, dependsOn: [installGrunt, grunt_webpackDist, grunt_webpackNoMin, grunt_webpackSelenium]) {
	outputs.upToDateWhen { false }
	args = ["replaceVersionAndCompress:$versionIsochrone"]
}

task docJavascript(dependsOn: grunt_doc)

task javadocJar(type: Jar, dependsOn: javadoc) {
	description = 'Builds a jar file including javadoc'
	from javadoc.destinationDir

	classifier 'javadoc'
}

task javascriptServerKarma(type: GruntTask) {
	outputs.upToDateWhen { false }
	args = ["testServer"]
}

task javascriptServerWebpack(type: GruntTask, dependsOn: [grunt_webpackDevelopment]) {
	outputs.upToDateWhen { false }
	args = ["webpackDevServer"]
}

task jettyWar(type: War) {
	from sourceSets.main.output
	from sourceSets.jetty.output
	from { configurations.jettyCompile.collect { it.isDirectory() ? it : zipTree(it) } }

	classifier = 'executable'
	exclude('**/META-INF/*.SF', '**/META-INF/*.RSA', '**/META-INF/*.DSA')
	manifest {
		attributes 'Main-Class': 'at.uibk.dbis.isomap.web.JettyServer'
	}

	// exclude files that webpack compiles to folder "dist/"
	exclude("css")
	exclude("images")
	exclude("js")
	exclude("index_devel.html")
	exclude("index_template.html")
}

task runEmbeddedJetty(type: JavaExec) {
	doFirst {
		// find alpn-boot jar file path
		def alpnBootJar
		sourceSets.jetty.runtimeClasspath.each { jar ->
			if (jar.path.contains("alpn-boot")) {
				alpnBootJar = jar
			}
		}

		jvmArgs = ['-Xbootclasspath/p:' + alpnBootJar]
	}

	classpath = sourceSets.jetty.runtimeClasspath
	main = 'at.uibk.dbis.isomap.web.JettyServer'
}

task sourcesJar(type: Jar, dependsOn: classes) {
	description = 'Builds a jar file including sources'
	from sourceSets.main.allSource

	classifier 'sources'
}

task testIntegration(type: Test) {
	dependsOn drivers.collect { tasks["testIntegration${it.capitalize()}"] }
}

task testJavascript(type: GruntTask) {
	outputs.upToDateWhen { false }
	args = ["test", "--force"]
}

task testWar(type: War, dependsOn: classes) {
	description = 'Builds the war file for testing'

	classpath = sourceSets.main.output + sourceSets.test.resources + project.configurations.runtime - project.configurations.providedRuntime
	classifier = 'test'

	// exclude files that webpack compiles to folder "dist/"
	exclude("css")
	exclude("images")
	exclude("js")
	exclude("index_devel.html")
	exclude("index_template.html")
}

// CI tasks

task jarAll(dependsOn: [jar, javadocJar, sourcesJar, shadowJar])
task warAll(dependsOn: [jettyWar, war, testWar])
task buildAll(dependsOn: [jarAll, warAll, build])
task daily(dependsOn: [asciidoctor, commitChangelog, check, javadoc, docJavascript, jarAll, warAll])

// task dependencies

tasks.check.dependsOn checkJavascript
tasks.check.dependsOn testIntegration
tasks.check.dependsOn testJavascript
tasks.clean.dependsOn cleanJavascript
tasks.cleanGeneratedBuildFiles.dependsOn cleanNodeModules
tasks.cleanJavascript.dependsOn cleanGeneratedBuildFiles
tasks.compileJava.dependsOn compileJavascript
tasks.daily.mustRunAfter clean
tasks.grunt_check.args = ["check", "--force"]
tasks.grunt_check.dependsOn installGrunt
tasks.grunt_compile.dependsOn installGrunt
tasks.grunt_doc.dependsOn installGrunt
tasks.grunt_test.dependsOn installGrunt
tasks.grunt_testServer.dependsOn installGrunt
tasks.grunt_webpackSelenium.dependsOn installGrunt
tasks.grunt_webpackDevelopment.dependsOn installGrunt
tasks.grunt_webpackDist.dependsOn installGrunt
tasks.grunt_webpackNoMin.dependsOn installGrunt
tasks.grunt_webpackDevServer.dependsOn installGrunt
tasks.grunt_webpackDevServer.mustRunAfter grunt_webpackDevelopment
tasks.installGrunt.dependsOn npmInstall
tasks.testJavascript.dependsOn installGrunt