build.gradle

apply from: 'wrapper.gradle'

def projectBuildVersion = org.bladerunnerjs.BuildVersionCalculator.calculateVersion(project)
def projectBuildMajorVersion = org.bladerunnerjs.BuildVersionCalculator.calculateMajorVersion(project)
def projectVersionIsDirty = org.bladerunnerjs.BuildVersionCalculator.isVersionDirty(project)
def projectBuildDate = org.bladerunnerjs.BuildVersionCalculator.calculateBuildDate(project)
def projectBuildHostname = org.bladerunnerjs.BuildVersionCalculator.calculateBuildHostname(project)
def projectCurrentBranch = org.bladerunnerjs.BuildVersionCalculator.calculateCurrentBranch(project)

logger.info "Build version calculated as: ${projectBuildVersion}"
logger.info "Build date is: ${projectBuildDate}"
logger.info "Build hostname is: ${projectBuildHostname}"
logger.info "Build branch is: ${projectCurrentBranch}"


def overrideBuildVersionPropertyName = "overrideBuildVersion"
if (project.hasProperty(overrideBuildVersionPropertyName)) {
	logger.info "Project has property ${overrideBuildVersionPropertyName} set, overriding calculated build version"
	projectBuildVersion = project.property(overrideBuildVersionPropertyName)
}

def overrideMajorVersionPropertyName = "overrideBuildMajorVersion"
if (project.hasProperty(overrideMajorVersionPropertyName)) {
	logger.info "Project has property ${overrideMajorVersionPropertyName} set, overriding calculated build version"
	projectBuildMajorVersion = project.property(overrideMajorVersionPropertyName)
}


[ "JAVA8_HOME", "JAVA7_HOME" ].each { envName ->
	def property = System.getenv()[envName]
	if (property == null)
	{
		throw new GradleException("The environment variable '${envName} must be set for the build to work correctly, please make sure it is set. Refer to README.md for info on the dev environment setup.")
	}
}

ext {
	RELEASE_BRANCH = "master"
}

allprojects {

	ext {
		buildVersion = projectBuildVersion
		buildDate = projectBuildDate
		buildHostname = projectBuildHostname
	}

	def projectContainingSharedLogic = project
	while (projectContainingSharedLogic != null) {
		def dependenciesFile = projectContainingSharedLogic.file('dependencies.gradle')
		if (dependenciesFile.isFile()) {
			apply from: dependenciesFile
			break
		}
		projectContainingSharedLogic = projectContainingSharedLogic.parent
	}

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

	repositories {
		mavenCentral()
		maven { url "http://bladerunnerjs.github.io/brjs-build-dependencies/repo" }
	}

	buildscript {
    	repositories {
    		mavenCentral()
    	}
	}

	tasks.withType(Copy) {
		fileMode = 0755
		includeEmptyDirs = false
	}
	tasks.withType(Sync) {
		fileMode = 0755
		includeEmptyDirs = false
	}
	tasks.withType(Zip) {
		fileMode = 0755
		includeEmptyDirs = false
	}

}

subprojects { p ->

	version = buildVersion
	group = 'org.bladerunnerjs'

	afterEvaluate { project ->

		if (project.plugins.hasPlugin(JavaPlugin)) {
			if(project.name == 'brjs-core' 
					|| project.name == 'brjs-core-tests'
					|| project.name == 'brjs-plugins') {
				sourceCompatibility = '1.8'
				targetCompatibility = '1.8'
			}
			else if(project.name == 'brjs-servlet') {
				sourceCompatibility = '1.6'
				targetCompatibility = '1.6'
			}
			else {
				sourceCompatibility = '1.7'
				targetCompatibility = '1.7'
			}

			project.tasks.withType(Test) { testTask ->
				test {
					testLogging {
						events 'skipped', 'failed'
						exceptionFormat 'full'
						info {
							displayGranularity = 0
						}
					}
				}
			}

			project.tasks.withType(JavaCompile) {
				options.compilerArgs += ['-Xlint:all,-path']
				options.encoding = 'UTF-8'
			}
		}

	}

}


task runAllJavaTests << { throw new GradleException("runAllJavaTests has been renamed to testJava") }


task testJava {
	description "Runs 'test' for all Java projects."
}
subprojects {
	afterEvaluate { project ->
		project.tasks.withType(Test) { testTask ->
			testJava.dependsOn testTask
		}
	}
}

task cleanJava {
	description "Runs clean for all Java projects."
}
subprojects {
	afterEvaluate { project ->
		if (project.plugins.hasPlugin(JavaPlugin.class)) {
			cleanJava.dependsOn project.clean
		}
	}
}


task build {
	description "Builds and tests the distribution. Runs 'build' on all subprojects."
}
def parentBuildTask = build
subprojects {
	afterEvaluate { subProject ->
		parentBuildTask.dependsOn subProject.getTasksByName('build',false)
	}
}

def getProperty = { project, property ->
if (!project.hasProperty(property)) {
	throw new GradleException("${property} property must be set")
}
return project.property(property)
}



/* Automated release stuff */

def getGitHubToken = { project ->
	return getProperty(project,"githubToken")
}

def getReleaseNoteJson = { project, tagVersion ->
	def releaseDataFile = file("releases/${tagVersion}.json")
	def releaseDataText = releaseDataFile.text
	releaseDataText = releaseDataText.replaceAll("@tagVersion@", tagVersion)
	releaseDataText = releaseDataText.replaceAll("@buildVersion@", buildVersion)
	def releaseNoteJson = new groovy.json.JsonSlurper().parseText( releaseDataText )
	return releaseNoteJson
}

import org.bladerunnerjs.github.*


task generateReleaseNotes, {
	def assembledReleaseNotesFile = file("${buildDir}/release-note.txt")
	inputs.property "projectBuildVersion", projectBuildVersion
	outputs.file assembledReleaseNotesFile
	doFirst {
    	def gitHubToken = getGitHubToken(project)
		def githubApi = new GitHubAPIBridge(project, "BladeRunnerJS", "brjs", gitHubToken)
    	def tagVersion = projectBuildMajorVersion

		def releaseNoteFile = file("releases/${tagVersion}.md")
		def milestoneJson = getReleaseNoteJson(project,tagVersion).milestone
		def milestones = milestoneJson.split(",").collect { it.trim() }
		def milestoneIds = githubApi.getMilestoneIds(milestones)

		def includeIssueLabels = ["bug", "feature", "enhancement", "experience", "breaking-change", "java-api", "js-api", " CaplinSupport"]
		def issueIncludeLabelsString = includeIssueLabels.join(", ").replaceAll(/^(.*),(.*)$/,'$1 or$2'); /* regex replaces the last ',' with 'or' */

		def excludeIssueLabels = ["invalid", "duplicate", "wont-fix", "wontfix", "ignore-release-note"]

		List<Issue> issues = new ArrayList<Issue>();
		milestoneIds.each { milestoneId ->
			issues.addAll( githubApi.getClosedIssuesForMilestone(milestoneId) )
		}

		List<Issue> releaseNoteIssues = new LinkedList<Issue>()
		issues.each {
			if (it.labels.intersect(includeIssueLabels) && !it.labels.intersect(excludeIssueLabels)) {
				releaseNoteIssues.add(it)
			}
		}


		def appendToReleaseNotes = []

		appendToReleaseNotes << ""
		appendToReleaseNotes << "<br/>"
		appendToReleaseNotes << "-------------"
		appendToReleaseNotes << "### API Documentation"
		appendToReleaseNotes << ""
		appendToReleaseNotes << "- [@tagVersion@ JavaScript API](http://apidocs.bladerunnerjs.org/@tagVersion@/js/)"
		appendToReleaseNotes << "- [@tagVersion@ Java Model API](http://apidocs.bladerunnerjs.org/@tagVersion@/java/)"
		appendToReleaseNotes << ""
		appendToReleaseNotes << "**Travis Build Status for @tagVersion@:**&nbsp;&nbsp;&nbsp;[![Build Status](https://travis-ci.org/BladeRunnerJS/brjs.svg?branch=@tagVersion@)](https://travis-ci.org/BladeRunnerJS/brjs)"
		appendToReleaseNotes << ""
		appendToReleaseNotes << "### Closed Issues"
		appendToReleaseNotes << "The following issues labelled ${issueIncludeLabelsString} have been closed:"
		appendToReleaseNotes << ""
		releaseNoteIssues.each {
			appendToReleaseNotes << "- ${it.toString()}"
		}
		appendToReleaseNotes << ""
		appendToReleaseNotes << "<sup>${issues.size} issues closed; ${releaseNoteIssues.size} labelled ${issueIncludeLabelsString} from ${milestoneIds.size} milestones: "
		milestoneIds.each { milestoneId ->
			if (milestoneId != milestoneIds.first()) {
				appendToReleaseNotes << "; "
			}
			def milestoneUrl = "${githubApi.getMilestoneUrl(milestoneId)}&state=closed"
			appendToReleaseNotes << "<a href=\"${milestoneUrl}\">${milestoneUrl}</a>"
		}
		appendToReleaseNotes << "</sub>"
		appendToReleaseNotes << ""
		appendToReleaseNotes << "### Found an Issue?"
		appendToReleaseNotes << "- [https://github.com/BladeRunnerJS/brjs/issues](https://github.com/BladeRunnerJS/brjs/issues) for any existing issues"
		appendToReleaseNotes << "- [https://github.com/BladeRunnerJS/brjs/issues/new](https://github.com/BladeRunnerJS/brjs/issues/new) to raise a new issues."
		appendToReleaseNotes << ""
		appendToReleaseNotes << ""
		appendToReleaseNotes << '<sub>Parts of this release note have been auto-generated. If you notice any problems with it <a href="https://github.com/BladeRunnerJS/brjs/issues/new">tell us</a></sub>'
		appendToReleaseNotes << ""
		appendToReleaseNotes << ""

		assembledReleaseNotesFile.parentFile.mkdirs()
		assembledReleaseNotesFile.createNewFile()
		assembledReleaseNotesFile.text = releaseNoteFile.text + "\n" + appendToReleaseNotes.join("\n")

    	ant.replace(file: assembledReleaseNotesFile) {
    		replacefilter(token:"@tagVersion@", value:tagVersion)
    		replacefilter(token:"@buildVersion@", value:buildVersion)
    	}
	}
}
generateReleaseNotes.shouldRunAfter ':brjs-sdk:distZip'

task githubRelease, dependsOn:[generateReleaseNotes, ':brjs-sdk:distZip', build], {
	doLast {
		def cutlassSdkProject = project(':brjs-sdk')
		def brjsZipPattern = "**/BladeRunnerJS-${projectBuildVersion}.zip"
		def brjsZip = fileTree(dir:cutlassSdkProject.buildDir, include:brjsZipPattern).singleFile

		if (!projectCurrentBranch.equals(RELEASE_BRANCH))
		{
			throw new GradleException("BladeRunnerJS ${projectBuildVersion} can only be released from '${RELEASE_BRANCH}' branch, you are currently on '${projectCurrentBranch}'.")
		}
		if (projectVersionIsDirty)
		{
			throw new GradleException("Project version is dirty, this version (${projectBuildVersion}) cannot be released.")
		}

    	def gitHubToken = getGitHubToken(project)
    	def githubApi = new GitHubAPIBridge(project, "BladeRunnerJS", "brjs", gitHubToken)
    	def tagVersion = projectBuildMajorVersion

		def releaseNoteFile = generateReleaseNotes.outputs.files.singleFile
		def releaseJson = getReleaseNoteJson(project,tagVersion)
    	Release release = githubApi.createReleaseForTag(tagVersion, releaseJson, releaseNoteFile.text)
		githubApi.uploadAssetForRelease(brjsZip, release)
	}
}


if (org.bladerunnerjs.OSCalculator.isWin32())
{
	configurations {
		curlDep
	}
	dependencies {
		curlDep dependency('curl-win32')
	}

    task downloadCurl, type:Copy, dependsOn:configurations.curlDep, {
    	from { configurations.curlDep.collect { zipTree(it) } }
		into "${buildDir}/curl"
    }

	githubRelease.doFirst {
		GitHubAPIBridge.CURL_PATH = fileTree(dir:downloadCurl.outputs.files.singleFile, include:"**/curl.exe").singleFile.path
	}
	githubRelease.dependsOn downloadCurl
}