build.gradle

// Copyright (c) 2003-present, Jodd Team (http://jodd.org)
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

plugins {
	id "com.jfrog.bintray" version "1.3"
}

description = '''

	Jodd is an open-source Java utility library and set of micro frameworks.
	Jodd tools enriches JDK with many powerful and feature rich utilities.
	It helps with everyday task, makes code more robust and reliable.
	Jodd frameworks is set of lightweight application frameworks, compact yet powerful.
	Designed following the CoC, DRY and SCS principles, it makes development
	simple, but not simpler.
'''

version = '3.7.0-20150805'

// --- properties -------------------------------------------------------------

ext {
	gradleScriptDir = "${rootProject.projectDir}/gradle"

	// libraries

	tomcatVersion = '7.0.47'
	jacocoVersion = '0.7.1.201405082137'

	lib = [
		mail:			'javax.mail:mail:1.4.5',
		activation:		'javax.activation:activation:1.1.1',
		servlet:		'javax.servlet:javax.servlet-api:3.0.1',
		jsp:			'javax.servlet.jsp:jsp-api:2.2',

		log_slf4j:			'org.slf4j:slf4j-api:1.7.2',
		log_slf4j_simple:	'org.slf4j:slf4j-simple:1.7.2',
		log_jcl:        	'commons-logging:commons-logging:1.1.3',

//		asm:			'org.ow2.asm:asm:4.1',

		junit: 			'junit:junit:4.12',
		hamcrest:       'org.hamcrest:hamcrest-core:1.3',
		mockito:		'org.mockito:mockito-all:1.9.5',
		hsqldb:			'org.hsqldb:hsqldb:2.2.9',
		h2db:			'com.h2database:h2:1.1.111',
		postgresql:		'org.postgresql:postgresql:9.4-1201-jdbc41',
		mysql:			'mysql:mysql-connector-java:5.1.35',
		winstone:		'net.sourceforge.winstone:winstone:0.9.10',
		//el_api:		'javax.el:el-api:2.2',
		el_api:			"org.apache.tomcat:tomcat-jasper:${tomcatVersion}",
		tomcat_embed:	[
							"org.apache.tomcat:tomcat-jasper:${tomcatVersion}",
							"org.apache.tomcat:tomcat-jasper-el:${tomcatVersion}",
							"org.apache.tomcat:tomcat-catalina:${tomcatVersion}",
							"org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}",
							"org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}",
							"org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}",
							"org.apache.tomcat.embed:tomcat-embed-logging-log4j:${tomcatVersion}"],
		jacoco_agent:	"org.jacoco:org.jacoco.agent:${jacocoVersion}:runtime@jar",
		jacoco_ant:		"org.jacoco:org.jacoco.ant:${jacocoVersion}",
	]

	commonManifest = [
		'Debug-Info' : 'on',
		'Built-By' : 'jodd.org',
		'Bundle-License' : 'http://jodd.org/license.html',
		'Bundle-Vendor' : 'Jodd',
		'Bundle-DocURL' : 'http://jodd.org',
		'Implementation-Version': version,
		'Implementation-Vendor': 'Jodd Team'
	]
}



// --- modules sets -----------------------------------------------------------

allprojects {
	version = rootProject.version

	ext.isSnapshot = version.contains("-");
	ext.isSubproject = project.parent != null

	repositories {
		jcenter()
		mavenCentral()
	}
}

def javaModules() {
	subprojects.findAll {
		it.name.contains('jodd-') &&
		!it.name.equals('jodd-bom')
	}
}

def javaBundleModules() {
	rootProject.subprojects.findAll {
		it.name.contains('jodd-') &&
		!it.name.equals('jodd-swingspy') &&
		!it.name.equals('jodd-joy') &&
		!it.name.equals('jodd-bom')
	}
}

def javaMobileModules() {
	rootProject.subprojects.findAll {
		it.name.equals('jodd-core') ||
		it.name.equals('jodd-bean') ||
		it.name.equals('jodd-props')
	}
}


// --- configuration ----------------------------------------------------------

apply plugin: 'idea'
apply plugin: 'eclipse'

// exclude folders from IDEA project
idea {
	module {
		excludeDirs += file('.idea')
	}
}

configure(javaModules()) {
	apply plugin: 'java'
	apply plugin: 'osgi'
	apply plugin: 'maven'
	apply plugin: 'signing'
	apply plugin: 'idea'
	apply plugin: 'eclipse'
	apply from: "${gradleScriptDir}/provided.gradle"
	apply from: "${gradleScriptDir}/publish-maven.gradle"

	group = 'org.jodd'

	// bintray

	apply plugin: 'com.jfrog.bintray'
	apply from: "${gradleScriptDir}/bintray.gradle"

	configurations {
		published
	}

	// compile

	sourceCompatibility = 1.7
	targetCompatibility = 1.7

	tasks.withType(JavaCompile) {
		options.encoding = 'UTF-8'
		options.compilerArgs << "-Xlint:-options"
		options.incremental = true
		//configurations.compile.transitive = false
	}
	compileJava.options.debug = true
	compileJava.options.fork = true

	task sourcesJar(type: Jar, dependsOn: classes) {
		classifier = 'sources'
		from sourceSets.main.allSource
	}
	task javadocJar(type: Jar, dependsOn: javadoc) {
		classifier = 'javadoc'
		from javadoc.destinationDir
	}

	// integration tests

	sourceSets {
		testInt
	}

	// idea fix no more needed since 13.0.2
//	idea {
//		module {
//			testSourceDirs += file('src/testInt/java')
//			testSourceDirs += file('src/testInt/resources')
//			scopes.TEST.plus += configurations.testIntCompile
//		}
//	}

	// use separate output folders for idea, don't mess with gradle
	idea {
		module {
			inheritOutputDirs true
		}
	}

	dependencies {
		testIntCompile sourceSets.main.output
		testIntCompile configurations.testCompile
		testIntCompile sourceSets.test.output
		testIntRuntime configurations.testRuntime
	}

	task testIntegration(type: Test, dependsOn: jar) {
		group 'verification'
		description 'Runs the integration tests.'

		testClassesDir = sourceSets.testInt.output.classesDir
		classpath = sourceSets.testInt.runtimeClasspath
		systemProperties['jar.path'] = jar.archivePath
	}

	// artifacts

	artifacts {
		archives jar
		archives sourcesJar
		archives javadocJar

		published jar
		published sourcesJar
		published javadocJar
	}

	jar {
		afterEvaluate {
			manifest.attributes << commonManifest
			manifest {
				name = project.moduleName
				version = project.version
				description = project.moduleDescription
				attributes 'Implementation-Title': project.moduleName
			}
		}
	}

	javadoc {
		exclude '**/asm5/**'
		afterEvaluate {
			configure(options) {
				windowTitle 'Jodd API Documentation'
				docTitle "$project.moduleName $project.version API Documentation"
				bottom = 'Copyright &#169; 2003-2013 <a href="http://jodd.org">Jodd Team</a>'
				breakIterator = true
				author = false
				encoding = 'UTF-8'
				docEncoding = 'UTF-8'
				stylesheetFile = file('src/main/javadoc/jodd.css')
				source = '1.7'
				failOnError = false
			}
		}
	}

	// JaCoCo

	configurations {
		jacoco
	}

	dependencies {
		jacoco lib.jacoco_agent
	}


	// Test: configure all tests, including integration

	tasks.withType(Test) { testTask ->
		configure(testTask) {
			beforeTest { descriptor ->
				logger.lifecycle("\t" + descriptor)
			}

			reports.html.enabled = true

			systemProperties = System.properties

			List<String> excludes = ['*Test*', '*.?', '*Foo*', '*.data.*', '*.tst*', 'jodd.asm5.*']

			jvmArgs "-javaagent:${configurations.jacoco.asPath}=destfile=${project.buildDir.path}/jacoco/${testTask.name}.exec," +
					"sessionid=HSServ,append=false,excludes=${excludes.join(':')}",
			 	'-Djacoco=true',
			 	'-Xms128m',
			 	'-Xmx512m',
			 	'-XX:MaxPermSize=128m',
			 	'-Duser.timezone=GMT'
		}
	}

}

// --- project ----------------------------------------------------------------

apply plugin: 'project-report'

def javaBundleModulesSources = javaBundleModules().sourceSets.main

task buildModules {
	dependsOn javaModules().build
}

task testAll {
	group 'Verification'
	description 'Runs all the tests.'

	dependsOn javaModules().test
	dependsOn javaModules().testIntegration
}

task clean(type: Delete) {
	group 'Project'
	description 'Cleans everything.'

	delete buildDir
}

task javadocAll(type: Javadoc) {
	group 'Documentation'
	description 'Builds the aggregated Java docs for all modules.'
	dependsOn buildModules

	maxMemory '512m'

	source javaBundleModulesSources.allJava
	exclude '**/asm4/**'

	destinationDir = file("$buildDir/reports/javadoc")
	classpath = files(javaBundleModulesSources.compileClasspath)

	configure(options) {
		windowTitle 'Jodd API Documentation'
		docTitle "Jodd Project $project.version API Documentation"
		bottom = 'Copyright &#169; 2003-2014 <a href="http://jodd.org">Jodd Team</a>'
		breakIterator = true
		author = false
		encoding = 'UTF-8'
		docEncoding = 'UTF-8'
		stylesheetFile = file('src/main/javadoc/jodd.css')
		source = '1.7'
	}

	inputs.files(javaBundleModulesSources.allSource + javaBundleModulesSources.compileClasspath)
	outputs.dir destinationDir
}

task testReport(type: TestReport) {
	group 'Reporting'
	description 'Generates tests report.'

	destinationDir = file("$buildDir/reports/tests")
	reportOn javaBundleModules()*.test
	reportOn javaBundleModules()*.testIntegration
}

configurations {
    jacoco {
        description 'JARs required for aggregate JacocoReport task.'
    }
}
dependencies {
    jacoco lib.jacoco_ant
}

task jacocoReport() {
	dependsOn testAll
	group = 'Reporting'
	description = 'Generates JaCoCo coverage reports for unit tests.'

	ant.taskdef(
			name:'jacocoreport',
			classname: 'org.jacoco.ant.ReportTask',
			classpath: configurations.jacoco.asPath
	)

	def coverageDir = "$buildDir/reports/coverage"
	ant.mkdir dir: coverageDir

	inputs.files(javaBundleModulesSources.allSource + javaBundleModulesSources.compileClasspath)
	outputs.dir file(coverageDir)

	doLast {
		ant.jacocoreport {
			executiondata {
				javaBundleModules().each {submodule ->
					fileset(dir: "${submodule.buildDir}/jacoco") {
						include name: '*.exec'
					}
				}
			}
			structure(name: 'Jodd Coverage Report') {
				javaBundleModules().each {submodule ->
					group(name: submodule.name) {
						classfiles {
							fileset dir: "${submodule.sourceSets.main.output.classesDir}", excludes: "**/jodd/asm5/**"
						}
					}
				}
			}
			html destdir: coverageDir
			xml destfile: coverageDir + '/jodd-coverage.xml'
		}
	}
}

// Coveralls task should be invoked manually, since we have integration tests
// that are executed only locally. After the release is build,
// go to Travis Build History: https://travis-ci.org/oblac/jodd/builds
// and select one of the jobs, then copy the job id from the URL line.
// Paste the job id into the .coverals.yml and invoke this task
// After few minutes, the coverage will appear here:
// https://coveralls.io/r/oblac/jodd
task coveralls() {
	//dependsOn jacocoReport
	group = 'Reporting'
	description = 'Submits Jacoco reports to Coveralls.'

	doLast {
		List<File> targetSrcDirs = new ArrayList<File>()

		for (main in javaBundleModulesSources) {
			targetSrcDirs += main.java.srcDirs
		}

		CoverallsReporter coverallsReporter = new CoverallsReporter();

		coverallsReporter.send(targetSrcDirs, file("build/reports/coverage/jodd-coverage.xml"))
	}
}

dependencyReport {
	projects = javaModules()
}

task bintray {
	group 'Publishing'
	description 'Publish all artifcats to bintray'

	dependsOn javaModules().bintrayUpload
	dependsOn(":jodd-bom:bintrayUpload")
}

// --- release ----------------------------------------------------------------

task release() {
	group 'Project'
	description 'Builds everything for the release.'

	dependsOn buildModules
	dependsOn testAll
	dependsOn javadocAll
	dependsOn testReport
	dependsOn jacocoReport
	dependsOn ':distribution:build'
	dependsOn projectReport
}

gradle.taskGraph.whenReady { taskGraph ->
	if (taskGraph.hasTask(release)) {

		println ""
		println "	You are about to run the 'release' task for Jodd project!"
		println "	This task builds distribution artifacts, but also runs"
		println "	integration tests and generates reports (javadoc, coverage...)"
		println "	For running integration tests you need databases running;"
		println "	please find more information here: http://jodd.org/code.html"
		println ""
		println "	Usually, you don't need to run this task. If you want to build"
		println "	distribution jars and run all unit tests, then just run the "
		println "	default 'build' task instead."
		println ""

		def char c

		def console = System.console()
		if (console) {
			line = console.readLine('	> Do you want to continue? [y/N]: ')
			line = line.trim()
			c = line.charAt(0)
		}
		else {
			println "	> Do you want to continue? [y/N]: "
			println ""

			// Can't use `console` because it does not work with Gradle Daemon
			def DataInputStream dis = new DataInputStream(System.in);

			c = dis.readByte()
		}

		if (!(c == 'Y' || c == 'y')) {
			throw new StopExecutionException("Execution terminated by user")
		}
	}
}

task version() {
	println "-----------------------"
	println "  Jodd ${version}"
	if (isSnapshot) println "  [snapshot]"
	println "-----------------------"
}

// --- wrapper ----------------------------------------------------------------

task wrapper(type: Wrapper) {
	gradleVersion = '2.5'
}