build.gradle

import static org.bladerunnerjs.BuildVersionCalculator.*

apply from: 'wrapper.gradle'


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

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

allprojects {
	
	ext {
		buildVersion = projectBuildVersion
		buildDate = projectBuildDate
		buildHostname = projectBuildHostname
	}
	
	def projectContainingSharedLogic = (project.parent) ? project.parent : project
	apply from: projectContainingSharedLogic.file('dependencies.gradle')
	
	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)) {
			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']
				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)
	}
}


task buildAndTestIE {
	description "Runs the 'build' task and also includes IE tests"
}
afterEvaluate { project ->
	buildAndTestIE.dependsOn build
	buildAndTestIE.dependsOn ':cutlass-sdk:testIE'
}


task buildAndTestIE_NoSysApps {
	description "Runs the 'build' task and also includes IE tests, ignoring the IE tests for systems apps"
}
afterEvaluate { project ->
    buildAndTestIE_NoSysApps.dependsOn build
    buildAndTestIE_NoSysApps.dependsOn ':cutlass-sdk:testJsIE'
}



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 releaseNoteJson = new groovy.json.JsonSlurper().parseText( releaseDataFile.text )
	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 = org.bladerunnerjs.BuildVersionCalculator.calculateMajorVersion(project)
		
		def releaseNoteFile = file("releases/${tagVersion}.md")
		def milestoneId = getReleaseNoteJson(project,tagVersion).milestone
		def includeIssueLabels = ["bug", "feature", "enhancement", "experience"]
		def issueIncludeLabelsString = includeIssueLabels.join(", ").replaceAll(/^(.*),(.*)$/,'$1 or$2'); /* regex replaces the last ',' with 'or' */	
		
		def excludeIssueLabels = ["invalid", "duplicate"]
		
		List<Issue> issues = githubApi.getClosedIssuesForMilestone(milestoneId)
		List<Issue> releaseNoteIssues = new LinkedList<Issue>()
		issues.each {
			if (it.labels.intersect(includeIssueLabels) && !it.labels.intersect(excludeIssueLabels)) {
				releaseNoteIssues.add(it)
			}
		}
		
		assembledReleaseNotesFile.parentFile.mkdirs()
		assembledReleaseNotesFile.createNewFile()
		assembledReleaseNotesFile.text = releaseNoteFile.text
		assembledReleaseNotesFile.text += "\n\n"
		assembledReleaseNotesFile.text += "-------------\n"
		assembledReleaseNotesFile.text += "### Closed Issues\n"
		assembledReleaseNotesFile.text += "<sup>${issues.size} issues closed; ${releaseNoteIssues.size} labelled ${issueIncludeLabelsString} - <a href=\"@milestoneURL@\">@milestoneURL@</a><sup>\n\n"
		releaseNoteIssues.each {
			assembledReleaseNotesFile.text += "- ${it.toString()}\n"
		}
		assembledReleaseNotesFile.text += "\n"
		assembledReleaseNotesFile.text += '<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>\n\n'
	
    	ant.replace(file: assembledReleaseNotesFile) {
    		replacefilter(token:"@tagVersion@", value:tagVersion)
    		replacefilter(token:"@buildVersion@", value:buildVersion)
    		replacefilter(token:"@milestonesURL@", value:githubApi.getMilestonesUrl())
    		replacefilter(token:"@milestoneURL@", value:githubApi.getMilestoneUrl(milestoneId))
    	}
	}
}


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

		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 = org.bladerunnerjs.BuildVersionCalculator.calculateMajorVersion(project)
    	
		def releaseNoteFile = generateReleaseNotes.outputs.files.singleFile
    	Release release = githubApi.createReleaseForTag(tagVersion, getReleaseNoteJson(project,tagVersion), 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
}