build-nexus.gradle

/*
 * Nexus Repository Integration
 */

allprojects {
	apply plugin: "net.saliman.properties"
	apply plugin: "nu.studer.credentials"

	/* We accept crypted credentials via "nu.studer.credentials" or plain
	 * credentials via gradle-local.properties.
	 */
	ext.registryUsername = credentials.user ?: project.properties['nexus.username']
	ext.registryPassword = credentials.password ?: project.properties['nexus.password']

	repositories {
		mavenLocal()
		mavenCentral()

		String publicURL = project.properties['nexus.public.url']
		String releasesURL = project.properties['nexus.releases.url']
		String snapshotsURL = project.properties['nexus.snapshots.url']

		if (publicURL) {
			maven {
				credentials {
					username project.properties['registryUsername']
					password project.properties['registryPassword']
				}
				url publicURL
			}
		}

		if (snapshotsURL) {
			maven {
				credentials {
					username project.properties['registryUsername']
					password project.properties['registryPassword']
				}
				url snapshotsURL
			}
		}

		if (releasesURL) {
			maven {
				credentials {
					username project.properties['registryUsername']
					password project.properties['registryPassword']
				}
				url releasesURL
			}
		}
	}
}

/************************
 * RELEASE vs SNAPSHOTS *
 ************************/

apply plugin: "org.ajoberstar.grgit"

if (grgit != null) {
	logger.debug("Git ${grgit.branch.current().name}")

	ext.gitClone = true
	ext.gitBranchName = grgit.branch.current().name

	if (ext.gitBranchName.startsWith("release")) {
		ext.gitSnapshotsBranch = false
		ext.registrySuffix = ""
	}
	else if (ext.gitBranchName.startsWith("development")) {
		ext.gitSnapshotsBranch = true
		ext.registrySuffix = "-SNAPSHOT"
	}
	else if ("master".equals(gitBranchName)) {
		ext.gitSnapshotsBranch = true
		ext.registrySuffix = "-SNAPSHOT"
	}
	else {
		ext.gitSnapshotsBranch = true

		def issueId = gitBranchName =~ /^(\d+)/

		if (issueId.size() > 0) {
			ext.gitIssueId = issueId[0][1]
			ext.registrySuffix = "-${gitIssueId}-SNAPSHOT"
		}
		else if ("HEAD".equals(gitBranchName)) {
			def lastTag = grgit.describe()
			println "Git lastTag ${lastTag}"

			if (lastTag != null && (lastTag.startsWith("rel_") || lastTag.startsWith("MP_v"))) {
				ext.gitSnapshotsBranch = false
				ext.registrySuffix = ""
			}
			else {
				ext.registrySuffix = "-SNAPSHOT"
			}
		}
		else {
			//throw new GradleException("Unsupported branch name ${gitBranchName}. Manage it!!")
			println ""
			println "WARNING:"
			println "WARNING: Unsupported branch name ${gitBranchName}. Manage it!!"
			println "WARNING:"
			println ""

			ext.gitSnapshotsBranch = true
			ext.registrySuffix = "-SNAPSHOT"
		}
	}

	//println "${gitSnapshotsBranch} ${registrySuffix}"
	logger.debug("${gitSnapshotsBranch} ${registrySuffix}")
}
else {
	println "No Git"

	ext.gitClone = false

	if (project.properties['nexus.release.mode'] == "true") {
		ext.registrySuffix = ""
	}
	else {
		ext.registrySuffix = "-SNAPSHOT"
	}
}

/*************************
 * TRACK CHANGED MODULES *
 *************************/

// Will collect path of modules with changes since last release
Set changedProjects = []

ext.changesMode = false;

def changesModeEnabled = Boolean.valueOf(project.properties["changes.mode.enabled"])
def changesVerboseMode = Boolean.valueOf(project.properties["changes.verbose.mode"])

//if (changesModeEnabled && grgit != null && project.properties['gitSnapshotsBranch'] == true) {
if (changesModeEnabled && grgit != null) {
	println "Git Branch ${grgit.branch.current().name}"

	def head = grgit.head();
	logger.debug("KK head=${head}")

	// Identity the most recent release tag reachable.
	// WARNING: Seems GitHut release Tag are not annotated tags
	def describeTag = grgit.describe(longDescr: true, match: ["rel_*"], tags: true)

	if (describeTag == null) {
		println "No releases found"
	}
	else {
		ext.changesMode = true;

		File smcChangesBarrier = new File(rootDir, ".smc_changes_barrier")

		if (smcChangesBarrier.exists()) {
			def content = smcChangesBarrier as String[]
			if (content.length > 0 && describeTag.startsWith(content[0])) {
				ext.changesMode = false;
			}
		}
	}

	def changesModeType = project.properties["changes.mode.type"]
	def matchNames = [
		"/package.json", "/package-loack.json", "/gulpfile.js", "/build.gradle",
		"/bnd.bnd"
	]

	if (ext.changesMode) {

		def collectChangedPath = {
			def p = "/" + it.toLowerCase()
			def v = false

			if (p.startsWith("/modules/")) {
				if (p.equals("/modules/build.gradle")) {
					v = false
				}
				else if (p.contains("/src/")) {
					v = true
					changedProjects.add(p.minus(~/\/src\/.*$/).replaceAll("/", ":"))
				}
				else {
					matchNames.each {
						if (!v && p.endsWith(it)) {
							v = true
							changedProjects.add(p.minus(it).replaceAll("/", ":"))
						}
					}
				}

				if (v && changesVerboseMode) {
					println "  ${p}"
				}
			}
			else if (p.startsWith("/themes/")) {
				if (p.equals("/themes/build.gradle")) {
					v = false
				}
				else if (p.contains("/src/")) {
					v = true
					changedProjects.add(p.minus(~/\/src\/.*$/).replaceAll("/", ":"))
				}
				else {
					matchNames.each {
						if (!v && p.endsWith(it)) {
							v = true
							changedProjects.add(p.minus(it).replaceAll("/", ":"))
						}
					}
				}

				if (v && changesVerboseMode) {
					println "  ${p}"
				}
			}
			else if (p.startsWith("/wars/")) {
				if (p.equals("/wars/build.gradle")) {
					v = false
				}
				else if (p.contains("/src/")) {
					v = true
					changedProjects.add(p.minus(~/\/src\/.*$/).replaceAll("/", ":"))
				}
				else {
					matchNames.each {
						if (!v && p.endsWith(it)) {
							v = true
							changedProjects.add(p.minus(it).replaceAll("/", ":"))
						}
					}
				}

				if (v && changesVerboseMode) {
					println "  ${p}"
				}
			}
			else if (p.startsWith("/ext/")) {
				if (p.equals("/ext/build.gradle")) {
					v = false
				}
				else if (p.contains("/src/")) {
					v = true
					changedProjects.add(p.minus(~/\/src\/.*$/).replaceAll("/", ":"))
				}
				else {
					matchNames.each {
						if (!v && p.endsWith(it)) {
							v = true
							changedProjects.add(p.minus(it).replaceAll("/", ":"))
						}
					}
				}

				if (v && changesVerboseMode) {
					println "  ${p}"
				}
			}
		}

		def productVersion = project.properties['product.version'] ?: "1.0.0"

		// Get Tag object (to have commit id)

		def lastTagName = describeTag.minus(~/-\d+-\w+$/)

		def lastReleaseTag = null

		grgit.tag.list().each { tag ->
			if (tag.name.equals(lastTagName)) {
				lastReleaseTag = tag
			}
		}

		if (lastReleaseTag == null) {
			lastReleaseTag = grgit.resolve.toTag(lastTagName)
		}

		println "Curr release..: ${productVersion}"
		println "Last ReleaseTag ${lastReleaseTag.getName()} : ${lastReleaseTag.shortMessage} : ${lastReleaseTag.dateTime} : ${lastReleaseTag.commit.id}"

		if (changesModeType != null && changesModeType.equals("diff")) {
			def diffs = grgit.diff(oldCommit: lastReleaseTag.commit)

			diffs.each{f ->
				if (changesVerboseMode) {
					println "${f.changeType} : ${f.oldPath} : ${f.newPath}"
				}

				def changeType = f.changeType.toString()

				if ("ADD".equals(changeType)) {
					collectChangedPath(f.newPath)
				}
				else if ("MODIFY".equals(changeType)) {
					collectChangedPath(f.oldPath)
				}
				else if ("DELETE".equals(changeType)) {
					collectChangedPath(f.oldPath)
				}
				else if ("COPY".equals(changeType)) {
					collectChangedPath(f.newPath)
				}
				else if ("RENAME".equals(changeType)) {
					collectChangedPath(f.oldPath)
					collectChangedPath(f.newPath)
				}
				else {
					collectChangedPath(f.oldPath)
					collectChangedPath(f.newPath)
				}
			}
		}
		else {
			// Collect local uncommitted changes

			def status = grgit.status();

			status.staged.allChanges.each { path ->
				collectChangedPath(path);
			}
			status.unstaged.allChanges.each { path ->
				collectChangedPath(path);
			}

			// Collect changes on commits ahead the tag

			def commits = grgit.log {
				range(lastReleaseTag.commit, head)
			}

			commits.each{c ->
				if (changesVerboseMode) {
					println "${c.id} : ${c.abbreviatedId} : ${c.shortMessage}"
				}

				grgit.show(commit: c).each{ rev ->
					rev.getAllChanges().each { path ->
						collectChangedPath(path);
					}
				}
			}
		}
	}
}

ext.changedProjects = changedProjects.sort()

println "** changesMode = ${changesMode}"

if (ext.changesMode) {
	println ""
	println "Modules with changes:"
	ext.changedProjects.each { println "  ${it}" }
	println ""
}