build.gradle

//----------------------------------------------------------------
//
//  Gradle project core configuration
//
//----------------------------------------------------------------

// Setup gradle and its plugins
plugins {
	// Setup gradle for java library builds
	id 'java-library'

	// // The one fat jar with dependencies (without shade)
	// id "com.github.onslip.gradle-one-jar" version "1.0.5"

	// Shadow plugin used to build the shade jar
	id 'com.github.johnrengelman.shadow' version '2.0.4'

	// jacoco code coverage for test
	id 'jacoco'
}

// Dependency providers to fetch from
repositories {
	google()
	gradlePluginPortal() 
	mavenCentral()

	// You can declare any other Maven/Ivy/file repository here.
}

//----------------------------------------------------------------
//
//  Project versioning
//
//----------------------------------------------------------------

// The Project version
version = '4.1.0'

// Setup java compilation version
sourceCompatibility = 1.8
targetCompatibility = 1.8

//----------------------------------------------------------------
//
//  JavaCommons-core integration
//
//----------------------------------------------------------------

// JavaCommons core compilation
task buildJavaCommonsCore(type: GradleBuild) {
	buildFile = './JavaCommons-core/build.gradle'
	tasks = ['fatJar']
}


// JavaCommons dstack compilation
task buildJavaCommonsDStack(type: GradleBuild) {
	buildFile = './JavaCommons-dstack/build.gradle'
	tasks = ['fatJar']
}

// Dependency linkage of core project build
compileJava.dependsOn buildJavaCommonsCore
compileJava.dependsOn buildJavaCommonsDStack

//----------------------------------------------------------------
//
//  Project dependencies
//
//----------------------------------------------------------------

// Dependencies used in the build
dependencies {
	
	// JavaCommons dependencies
	//---------------------------------------

	// Get and compile against the -all.jar lib file from javacommons core + DStack
	// note that compileOnly + testImplementation ensures this file is not included 
	// in any of the 3 jar builds, but still make it part of the test suite
	compileOnly fileTree(dir: './JavaCommons-core/build/libs', include: ['*-all.jar']) 
	testImplementation fileTree(dir: './JavaCommons-core/build/libs', include: ['*-all.jar']) 

	compileOnly fileTree(dir: './JavaCommons-dstack/build/libs', include: ['*-all.jar']) 
	testImplementation fileTree(dir: './JavaCommons-dstack/build/libs', include: ['*-all.jar']) 

	// This dependencies is exported to consumers, that is to say found on their compile classpath.
	//-------------------------------------------------------------------------------------------------------------------

	// Embedded tomcat 
	// @TODO upgrade 8.5.32 to 9.x (and fix whatever breaks it)
	api "org.apache.tomcat.embed:tomcat-embed-core:8.5.32"
	api "org.apache.tomcat.embed:tomcat-embed-jasper:8.5.32"
	// api "org.apache.tomcat.embed:tomcat-embed-el:8.5.32"
	// api "org.apache.tomcat.embed:tomcat-embed-websocket:8.5.32"

	// Fileupload servlet support
	api "commons-fileupload:commons-fileupload:1.3.3"

	// This dependencies is used internally, and not exposed to consumers on their own compile classpath.
	//-------------------------------------------------------------------------------------------------------------------
	// implementation 'com.google.guava:guava:23.0'

	// Testing dependencies
	//-------------------------------------------------------------------------------------------------------------------
	testImplementation 'junit:junit:4.12'
	testImplementation 'com.carrotsearch:junit-benchmarks:0.7.2'

}

//----------------------------------------------------------------
//
//  Jar build steps
//
//----------------------------------------------------------------

//
// Base JAR build settings
//
// `gradle jar`
//
jar {
	// Archive name overwrite
	archiveName = project.name+"-"+project.version+"-nodep"+".jar"
	description = "Build the "+archiveName+" with no dependencies"

	// Inherit the main jar manifest
	manifest {
		attributes(
			'Implementation-Title': project.name,
			'Implementation-Version': project.version
		)
	}
}

//
// Shadow jar - dependencies are shaded
//
// `gradle shadowJar`
//
shadowJar {
	// Archive name overwrite
	archiveName = project.name+"-"+project.version+"-shade"+".jar"
	description = "Build the "+archiveName+" with all dependencies shaded"

	// Inherit the main jar manifest
	manifest {
		inheritFrom project.tasks.jar.manifest
	}

	// Shade depencies under "picoded.shade"
	relocate "picoded", "picoded"
	relocate "org", "picoded.shade.org"
	relocate "com", "picoded.shade.com"
	relocate "oracle", "picoded.shade.oracle"
}

//
// Fat jar - dependencies are included, and not shaded
//
// `gradle shadowJar`
//
task fatJar(type: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar) {
	// Archive name overwrite
	archiveName = project.name+"-"+project.version+"-all"+".jar"
	description = "Build the "+archiveName+" with all dependencies"

	//
	// Note that the following is extended heavily from the default setup of shadowJar task
	// See : https://github.com/johnrengelman/shadow/blob/7ef6fc2699627f172b05a3bd3523201d63bb588f/src/main/groovy/com/github/jengelman/gradle/plugins/shadow/ShadowJavaPlugin.groovy#L38-L63
	//

	// NOTE : I dunno what this is - but it was setup in the default config
	conventionMapping.with {
		map('classifier') {
			'all'
		}
	}
	// Build from the main output
	from sourceSets.main.output
	// Load default configurations
	configurations = [project.configurations.findByName('runtimeClasspath') ? project.configurations.runtimeClasspath : project.configurations.runtime]
	// Inherit the main jar manifest
	manifest {
		inheritFrom project.tasks.jar.manifest
	}
	// Project dependencies libraries
	doFirst {
		def files = project.configurations.findByName(com.github.jengelman.gradle.plugins.shadow.ShadowBasePlugin.CONFIGURATION_NAME).files
		if (files) {
			def libs = [project.tasks.jar.manifest.attributes.get('Class-Path')]
			libs.addAll files.collect { "${it.name}" }
			manifest.attributes 'Class-Path': libs.findAll { it }.join(' ')
		}
	}
	// Exclude signed jar signatures?
	exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA')

	// Disable relocation
	relocate "picoded", "picoded"
	relocate "org", "org"
	relocate "com", "com"
	relocate "oracle", "oracle"
}

// Define the equivalent of buildAll
// for the build process done by "gradle build"
artifacts {
	archives fatJar
	archives shadowJar
	archives jar
}

//----------------------------------------------------------------
//
//  Concurent test threads
//
//----------------------------------------------------------------

// Adjust test to run concurrently
test {
	// Exclude performance related test
	// exclude "**/perf/*.java"
	// exclude "**/*_perf*"

	// Setup test to run on parllel threads = to number of processors by default
	if (project.hasProperty('maxParallelForks')) {
		maxParallelForks = project.maxParallelForks as int
	} else {
		// As our test tends to be io-blocked rather then cpu
		// we will run more tests in parallels
		maxParallelForks = (Runtime.runtime.availableProcessors() * 2) as int
	}
	
	// Set up the number of tests per fork
	if (project.hasProperty('forkEvery')) {
		forkEvery = project.forkEvery as int
	}
}

// Custom incremental test running
// (Only run tests directly related to a changed class)
class TestWatcher extends Test {
	@TaskAction
	void executeTests(IncrementalTaskInputs inputs) {
		// Process list of changed .classes file
		if (inputs.incremental) {
			// Include pattern to indicate which test classes should run
			this.filter.includePatterns = []

			// Get the test folder directories
			// def outputDir = this.project.sourceSets['test'].output.classesDir.absolutePath;

			// Iterate list of input files
			inputs.outOfDate { InputFileDetails change ->
				// Get the candidate file
				def candidate = change.file.absolutePath

				// Consider only if it ends with .class file
				if (candidate.endsWith('.class')) {
					// Get the filename (after processing)
					def pathSplit = candidate.replace('.class', '').split("/")

					// Strip off the folder path
					def filename = pathSplit[ pathSplit.size() - 1 ]
					
					// Add the filename into the include pattern
					this.filter.includePatterns += "*"+filename+"*"

					// candidate = candidate
					// 			.replace('.class', '')
					// 			.replace(outputDir, '')
					// 			.substring(1)
					// 			.replace(File.separator, '.')
					// this.filter.includePatterns += candidate
				}
			}
		}

		// Execute the respective test
		super.executeTests()
	}
}

// Incremental testing
task incrementalTest(type: TestWatcher) {
	// Exclude performance related test
	// exclude "**/perf/*.java"
	// exclude "**/*_perf*"

	// Setup test to run on parllel threads = to number of processors by default
	if (project.hasProperty('maxParallelForks')) {
		maxParallelForks = project.maxParallelForks as int
	} else {
		// As our test tends to be io-blocked rather then cpu
		// we will run more tests in parallels
		maxParallelForks = (Runtime.runtime.availableProcessors() * 2) as int
	}
	
	// Set up the number of tests per fork
	if (project.hasProperty('forkEvery')) {
		forkEvery = project.forkEvery as int
	}
}

//----------------------------------------------------------------
//
//  Custom src-beautify / prettifier
//  and compile aliases (with auto srcBeautify)
//
//----------------------------------------------------------------

// srcBeautify, with input file mapping (to skip srcBeautify steps if needed)
def srcBeautify_inputFiles = project.fileTree(dir: "src", include: "**/*.java")
def srcBeautify_outputDir = "${project.buildDir}/build-util/java-fromatter/output/"
task srcBeautify(type:Exec) {
	// Input file tracking, to skip command if its not needed
	inputs.files(srcBeautify_inputFiles)
	outputs.dir(srcBeautify_outputDir)

	// The build formatter command
	workingDir '.'
	commandLine './build-util/java-formatter/parallel_format.sh','./src'
}
task prettify(dependsOn: srcBeautify) 

// Doing compile alias for java
task src(dependsOn: compileJava) 
task source(dependsOn: src) 
task compile(dependsOn: src) 

// Forcing srcBeautify on src step
src.dependsOn srcBeautify

//----------------------------------------------------------------
//
//  Jacoco test coverage
//
//----------------------------------------------------------------

jacoco {
	toolVersion = "0.8.0"
}

jacocoTestReport {
	// Build the report
	reports {
		xml.enabled true
		csv.enabled true

		// Report format compatible with codeconv.io
		xml.destination file("${buildDir}/reports/jacoco/report.xml")
		csv.destination file("${buildDir}/reports/jacoco/report.csv")
	}
}

//----------------------------------------------------------------
//
//  Quick multibuild steps
//
//----------------------------------------------------------------

task buildAll {
	description = "Build all 3 jars: jar, shadowJar, fatJar"

	dependsOn jar
	dependsOn shadowJar
	dependsOn fatJar
}

task testAndBuildAll {
	description = "Performs the full test suite, then build all 3 jars: jar, shadowJar, fatJar"

	dependsOn jacocoTestReport
	dependsOn buildAll
}