build.gradle

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.4.10-SNAPSHOT'
//version = '3.4.9'


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

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

	// libraries

	tomcatVersion = '7.0.47'
	jacocoVersion = '0.6.3.201306030806'

	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:			'org.slf4j:slf4j-api:1.7.2',
		simpleLog:		'org.slf4j:slf4j-simple:1.7.2',
//		asm:			'org.ow2.asm:asm:4.1',

		junit: 			'junit:junit:4.11',
		mockito:		'org.mockito:mockito-all:1.9.5',
		hsqldb:			'org.hsqldb:hsqldb:2.2.9',
		h2db:			'com.h2database:h2:1.1.111',
		postgresql:		'postgresql:postgresql:9.1-901-1.jdbc4',
		mysql:			'mysql:mysql-connector-java:5.1.21',
		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}",

		// Animal Sniffer Ant Task and Java 1.5 API signature file
		// not using 1.9 for the time being due to MANIMALSNIFFER-34
		animal_sniffer: 'org.codehaus.mojo:animal-sniffer-ant-tasks:1.8',
		java15_signature: 'org.codehaus.mojo.signature:java15:1.0@signature',
	]

	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.endsWith("-SNAPSHOT")
	ext.isSubproject = project.parent != null

	repositories {
		mavenCentral()
	}
}

subprojects {
}

def javaModules() {
	subprojects.findAll { it.name.contains('jodd-') }
}

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

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



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

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

	group = 'org.jodd'

	// compile

	sourceCompatibility = 1.5
	targetCompatibility = 1.5

	tasks.withType(Compile) {
		options.encoding = 'UTF-8'
		options.compilerArgs << "-Xlint:-options"
	}
	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 {
		testIntegration {
			java.srcDir file('src/test-integration/java')
			resources.srcDir file('src/test-integration/resources')
		}
	}

	dependencies {
		testIntegrationCompile sourceSets.main.output
		testIntegrationCompile configurations.testCompile
		testIntegrationCompile sourceSets.test.output
		testIntegrationRuntime configurations.testRuntime
	}

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

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

	// artifacts

	artifacts {
		archives jar
		archives sourcesJar
		archives javadocJar
	}

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

	javadoc {
		exclude '**/asm4/**'
		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.5'
			}
		}
	}

	// 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*', '*\$*']

			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'
		}
	}

	// Animal Sniffer

	configurations {
		animalSniffer
		javaApiSignature
	}

	dependencies {
		animalSniffer(lib.animal_sniffer)
    	javaApiSignature(lib.java15_signature)
    }

	// copy the resolved Animal Sniffer signature dependency artifact to a known location and name
	task copyJavaApiSignature(type: Copy) {
		from configurations.javaApiSignature
		into "$buildDir/javaApiSignature/"
		rename '.*signature', 'javaApi.signature'
	}

	// prepare the Animal Sniffer signature copy every time (before) we compile
	compileJava.dependsOn copyJavaApiSignature

	// and then after compilation, run the Animal Sniffer tool
	compileJava << {
		print "$buildDir/javaApiSignature/"
		ant.taskdef(
				name: 'animalSniffer',
				classname: 'org.codehaus.mojo.animal_sniffer.ant.CheckSignatureTask',
				classpath: configurations.animalSniffer.asPath
		)

		ant.animalSniffer(
				signature: "$buildDir/javaApiSignature/javaApi.signature",
				classpath: sourceSets.main.compileClasspath.asPath) {
			path(path: sourceSets.main.output.classesDir)
			ignore(className: "java.nio.CharBuffer")
		}
	}
}

// --- 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-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.5'
	}

	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}"
						}
					}
				}
			}
			html destdir: coverageDir
		}
	}
}

// --- 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
}

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

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