Mercurial > public > develkit
view init40pom.gradle @ 301:74d939ce70d5
more printlns
author | Marc Davis <davis@ssdt-ohio.org> |
---|---|
date | Wed, 01 Feb 2023 08:12:46 -0500 |
parents | 2cfb28ce55d6 |
children |
line wrap: on
line source
import groovy.transform.Sortable import groovy.transform.ToString import groovy.transform.TupleConstructor buildscript { repositories { maven { url 'https://docker.ssdt.io/artifactory/ssdt-repo' } maven { url 'https://docker.ssdt.io/artifactory/gradle-plugins' } } } // buildScan { termsOfServiceUrl = 'https://gradle.com/terms-of-service'; termsOfServiceAgree = 'yes' } final GradleVersion gradleCurrent = GradleVersion.current() final GradleVersion gradleV410 = GradleVersion.version('4.10') println "Gradle Version: $gradleCurrent" if (gradleCurrent < gradleV410) { throw new RuntimeException("this init script requires Gradle version 4.10 or higher") } gradle.ext.ssdtDevelkitLocation = gradle.ext.has('ssdtDevelkitLocation') ? gradle.ssdtDevelkitLocation : 'http://hg.ssdt-ohio.org/browse/public/develkit' ant.property(file: System.getProperty('user.home') + "/.ssdt/private.properties") gradle.ext.ivyUserDir = ant.properties['ivy.default.ivy.user.dir'] ?: System.getProperty('user.home') + "/.ivy2" gradle.ext.ssdtProjectId = System.getenv('bamboo_project_id') ?: rootProject.name gradle.addListener(new ArtifactoryGradleSettings()) def hostname try { hostname = "hostname".execute().text.toLowerCase().readLines().first() } catch (e) { hostname = 'unknown' } gradle.ext.bambooBuild = System.getenv().any { it.key.toLowerCase().contains('bamboo') } || hostname?.startsWith('ssdt-ba') if (!rootProject.hasProperty("bambooLocalBuild")) { gradle.ext.bambooLocalBuild = false } else { gradle.ext.bambooLocalBuild = rootProject.bambooLocalBuild.toBoolean() } if (gradle.bambooLocalBuild) { println "Bamboo local build active" } gradle.ext.bambooPlan = (System.getenv('BAMBOO_PLAN') ?: 'UNKNOWN-UNKNOWN-JOB1').split('-')[0..1].join('-') logger.info "Bamboo plan: ${gradle.bambooPlan}" gradle.ext.buildTimestamp = System.currentTimeMillis().toString().padLeft(14, '0') gradle.ext.hgRepositoryUrl = "" try { gradle.ext.hgRepositoryUrl = ("hg path".execute().text.split('=') ?: ['', ''])[1].trim() } catch (e) { } def springModuleTranslator = [ 'spring-transaction': 'spring-tx', 'spring-web-servlet': 'spring-webmvc', ].withDefault { it } gradle.ext.normalizeSpring = { DependencyResolveDetails details -> if (details.requested.group == 'org.springframework' && details.requested.name.startsWith('org.springframework.')) { def shortName = springModuleTranslator[details.requested.name.replace('org.springframework.', 'spring-').replace('.', '-')] details.useTarget(group: 'org.springframework', name: shortName, version: details.requested.version) } if (details.requested.group == 'org.springframework.security' && details.requested.name.startsWith('org.springframework.')) { def shortName = springModuleTranslator[details.requested.name.replace('org.springframework.', 'spring-').replace('.', '-')] details.useTarget("${details.requested.group}:$shortName:${details.requested.version}") } } gradle.ext.runtimeInfo = new RuntimeInfo() if (System.env.DOCKER_HOST ) { if (System.env.DOCKER_HOST.contains('tcp:')) { gradle.ext.dockerEngineUrl = "https:${System.env.DOCKER_HOST?.minus('tcp:')}" } gradle.ext.dockerEngineUrl = System.env.DOCKER_HOST } setBranchInfo() loadEnvironments() gradle.environment.put('hgRepositoryUrl', gradle.hgRepositoryUrl) gradle.environment.put('branchName', gradle.branch.name) gradle.environment.put('branchStream', gradle.branch.stream) gradle.environment.put('branchHash', gradle.branch.hash) def cacheTimeout = 60 * 60 * 8 if (gradle.environment['dependencyTimeout']) { cacheTimeout = gradle.environment['dependencyTimeout'] as Integer println "setting changing dependency timeout to $cacheTimeout seconds" } gradle.ext.cacheTimeout = cacheTimeout rootProject.ext.indyCapable = { boolean capable = true try { Class.forName('java.lang.invoke.MethodHandle') } catch (e) { capable = false } capable && !rootProject.hasProperty('skipIndy') } rootProject.ext.useIndy = { boolean indy = false // first, check if a system property activates indy support indy |= System.hasProperty('indy') && Boolean.valueOf(System.getProperty('indy')) // check ssdt environment for indy property. indy |= (gradle.environment.indy) ? gradle.environment.indy.toBoolean() : false // check if the main project has an extension property setting indy (-Pindy). if (rootProject.hasProperty('indy')) { indy = (Boolean.valueOf(rootProject.indy)) } // set the groovy runtime system property to ensure forked junit test will get the indy flag properly if (indy && rootProject.indyCapable()) System.setProperty("groovy.target.indy", "true") indy && rootProject.indyCapable() } println "Indy available: ${rootProject.indyCapable()} enabled: ${rootProject.useIndy()}" if (gradle.bambooBuild) { file('build-number.txt').text = "build.number=${gradle.branch.buildNumber ?: -1 }\n" gradle.ext.ssdtGradlekitLocation = gradle.ext.has('ssdtGradlekitLocation') ? gradle.ssdtGradlekitLocation : 'http://hg.ssdt-ohio.org/ssdt/gradlekit/raw-file/tip' logger.info "applying SSDT artifactory Gradle Settings (bamboo: $gradle.bambooBuild host: $hostname)" println "applying SSDT artifactory Gradle Settings (bamboo: $gradle.bambooBuild host: $hostname)" apply from: "${gradle.ssdtGradlekitLocation}/artifactory40pom.gradle" println "Finished applying SSDT artifactory Gradle Settings (bamboo: $gradle.bambooBuild host: $hostname)" } if (!rootProject.hasProperty('disableMetrics')) { println "applying SSDT metrics40.gradle" apply from: "${gradle.ssdtDevelkitLocation}/metrics40.gradle" } rootProject.afterEvaluate { r -> if (gradle.bambooBuild && r.hasProperty('requireJavaVersion')) { gradle.runtimeInfo.requireJava( r.getProperty('requireJavaVersion') ) } if (!gradle.bambooBuild && !r.file('.idea/copyright/ODE.xml').exists() ) { updateCopyrightProfile(r) } } def findComponent(project, name) { project.component.find { it.@name == name } } wrapper { distributionType = org.gradle.api.tasks.wrapper.Wrapper.DistributionType.ALL } allprojects { configurations.all { resolutionStrategy.cacheChangingModulesFor gradle.cacheTimeout, 'seconds' resolutionStrategy.cacheDynamicVersionsFor gradle.cacheTimeout, 'seconds' } configurations.all { resolutionStrategy.eachDependency { DependencyResolveDetails details -> if (details.requested.group == 'org.ssdt_ohio' && !details.requested.version ) { details.useVersion( "latest.${gradle.branch.defaultDependencyStatus}" ) } if (details.requested.version == 'default') { details.useVersion("latest.${gradle.branch.defaultDependencyStatus}" ) } if (project.hasProperty("overrideCommon")) { if (details.requested.group == 'org.ssdt_ohio' && details.requested.name.contains('ssdt.common.')) { details.useVersion(project.overrideCommon) } } if (project.hasProperty("overrideVui")) { if (details.requested.group == 'org.ssdt_ohio' && details.requested.name.startsWith('vui.')) { details.useVersion(project.overrideVui) } } if (project.hasProperty("overrideUsasCore")) { if (details.requested.group == 'org.ssdt_ohio' && details.requested.name.startsWith('usas.') && !details.requested.name.startsWith('usas.vui')) { details.useVersion(project.overrideUsasCore) } } if (project.hasProperty("overrideUspsCore")) { if (details.requested.group == 'org.ssdt_ohio' && details.requested.name.startsWith('usps.') && !details.requested.name.startsWith('usps.vui')) { details.useVersion(project.overrideUspsCore) } } } } task cleanLocal(description: "removes all artifacts from developer's local repository") { doLast { def local = project.repositories.find { it.name == 'local' } if (local) { logger.info "removing local repo: $it" new File(System.properties['user.home'] + "/.ssdt/local-repo").deleteDir() def localDir = new File(gradle.ivyUserDir + "/local") localDir.deleteDir() logger.info "verifying removal of local repo" if (localDir.exists()) { throw new org.gradle.api.GradleException("Unable to clean ${localDir}. Files may be locked by another process.") } } } } cleanLocal.onlyIf { project.repositories.any { it.name == 'local' } } project.ext.previousBuildenv = project.file('build/buildenv.txt').exists() ? project.file('build/buildenv.txt').text : 'none' tasks.addRule("Pattern: <environment>As[Test]Properties: Generates <environment>.properties as resource or Test resource") { String taskName -> if ((taskName - 'Test').endsWith("AsProperties") && !taskName.startsWith('clean')) { // def t = taskName.contains('Test') ? processTestResources.destinationDir : processResources.destinationDir def t = taskName.contains('Test') ? sourceSets.test.output.resourcesDir : sourceSets.main.output.resourcesDir def e = (taskName - 'Test' - 'AsProperties').capitalize() task(taskName) { ext.outputDir = t ext.propertyFile = "${e.toLowerCase()}.properties" ext.buildenv = project.file('build/buildenv.txt') inputs.files project.file("../environment${e}.groovy"), project.file("../private${e}.groovy"), project.file('../private.properties') outputs.files new File(outputDir,propertyFile), buildenv outputs.upToDateWhen { gradle.env == project.previousBuildenv && outputs.getFiles().every { it.exists() } } doLast { t.mkdirs() outputDir.mkdirs() buildenv.text = gradle.env def ps = gradle."environment${e}".toProperties() ps['ssdt.project'] = project.name def pf = new File(outputDir,propertyFile) ext.outputPropertyFile = pf ps.store(pf.newOutputStream(), "by $taskName of $this") def l = pf.readLines().sort() pf.text = l.join('\n').replaceAll("\\.PARENT","") } } } } } subprojects { it.ext.environment = gradle.environment dependencyLocking { if (gradle.branch.isRelease()) { lockAllConfigurations() } } task("releaseLock" ) { description = "Create release dependencies Lock files" doFirst { assert gradle.startParameter.writeDependencyLocks : "must include --write-locks or --update-locks option when locking dependencies" } doLast { if (!gradle.branch.isRelease()) { throw new BuildCancelledException("releaseLock is only valid on release or hotfix branch.") } configurations.findAll { it.canBeResolved }.findAll { c -> def n = c.name.toLowerCase() ['compile','runtime','provided'].any { n.contains(it) } }.each { it.resolve() } } } } rootProject.afterEvaluate { tasks.addRule("release{Major|Minor|Patch|n.n.n}: create release branch or update release Lock file") { String taskName -> def matcher = (taskName =~ /^release(Major|Minor|Patch|\d{1,3}\.\d{1,3}\.\d{1,3})$/) if (matcher.matches()) { task('doReleaseBranch') { ext.requested = matcher[0][1].toLowerCase() doLast { def releaseVersion = determineReleaseVersion(requested) def releaseStream = releaseVersion.isHotfix() ? 'hotfix' : 'release' println "-" * 60 println "Preparing to create branch\n" println "\tproject:\t${gradle.rootProject.name}" println "\tcurrent:\t${gradle.branch} ($gradle.branch.version)" println() println "\ttype :\t${releaseStream.toUpperCase()}" println "\tversion:\t${releaseVersion}" println "\ttarget :\t${releaseStream}/v${releaseVersion}" println() println("-" * 60) println "DRY RUN".center(60) println("-" * 60) println "hg flow ${releaseStream} start v${releaseVersion} --dirty --dry-run".execute().text println "-" * 60 if (!confirmPrompt("Continue?")) { throw new BuildCancelledException("release branching canceled by user request") } println "hg flow ${releaseStream} start v${releaseVersion} --dirty".execute().text println "hg update ${releaseStream}/v${releaseVersion}".execute().text setBranchInfo() println "-" * 60 println " Be sure to execute 'releaseLock' task to update the release.lock file before proceeding." println "-" * 60 } } def branchTasks = ['doReleaseBranch'] task(taskName) { dependsOn branchTasks } branchTasks.tail().inject(branchTasks.head()) { a, b -> tasks[b].mustRunAfter a b } } } } private static String readLine(String message, String defaultValue = null) { String _message = "> $message" + (defaultValue ? " [$defaultValue] " : "") if (System.console()) { return System.console().readLine(_message) ?: defaultValue } println "$_message " System.in.newReader().readLine() ?: defaultValue } private static boolean confirmPrompt(String message, boolean defaultValue = false) { String defaultStr = defaultValue ? 'Y' : 'n' String consoleVal = readLine("${message} (Y|n)", defaultStr) if (consoleVal) { return consoleVal.toLowerCase().startsWith('y') } defaultValue } private Version determineReleaseVersion(String requested) { if (requested == 'major') { return gradle.branch.version.nextMajor() } else if (requested == 'minor') { return gradle.branch.version.nextMinor() } else if (requested == 'patch') { return gradle.branch.version.nextPatch() } else { return new Version(*requested.split(/\./)*.toInteger(), false) } } class ArtifactoryGradleSettings extends BuildAdapter implements BuildListener { def void projectsEvaluated(Gradle gradle) { def ssdtArtifactory = 'https://docker.ssdt.io/artifactory' Project root = gradle.getRootProject() def branchVersioning = gradle.rootProject.version == 'unspecified' root.allprojects { def thisProject = delegate thisProject.status = 'integration' if (gradle.branchStream) { if (branchVersioning) { thisProject.version = gradle.branch.version thisProject.status = gradle.branch.defaultDependencyStatus } else { thisProject.status = 'integration' def fixupVersion = thisProject.version - ".SNAPSHOT" if (gradle.branchStream == 'feature') { fixupVersion = fixupVersion + ".SNAPSHOT" } if (gradle.branchStream == 'develop') { fixupVersion = fixupVersion + ".SNAPSHOT" } if (gradle.branchStream in ['production', 'release', 'hotfix']) { thisProject.status = 'release' } thisProject.version = fixupVersion } } repositories { if (!gradle.bambooBuild || gradle.bambooLocalBuild) { ivy { name = 'local' artifactPattern gradle.ivyUserDir + '/local/[artifact]-[revision](-[classifier]).[ext]' ivyPattern gradle.ivyUserDir + "/local/[module]-ivy-[revision].xml" } } if (!gradle.bambooBuild) { mavenLocal() } if (gradle.branchStream == 'feature') { ivy { name = 'ssdt-branches' url = "${ssdtArtifactory}/ssdt-branches/${gradle.branchHash}/" layout "pattern", { artifact "[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]" ivy "[organization]/[module]/ivy-[revision].xml" } } } ivy { name = 'ssdt-releases' url = "${ssdtArtifactory}/ssdt-releases" layout "pattern", { artifact "[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]" artifact "[organization]/[module]/[revision]/[artifact]-[revision](-[classifier]).[ext]" ivy "[organization]/[module]/ivy-[revision].xml" m2compatible = true } } ivy { name = 'ssdt-snapshots' url = "${ssdtArtifactory}/ssdt-snapshots" layout "pattern", { artifact "[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]" artifact "[organization]/[module]/[revision]/[artifact]-[revision](-[classifier]).[ext]" ivy "[organization]/[module]/ivy-[revision].xml" m2compatible = true } } maven { name = 'ssdt-repository' url = "${ssdtArtifactory}/repository" } } def remoteRepos = thisProject.repositories.findAll { it.hasProperty('url') && !(it.name.toLowerCase().contains('local') || it.url.toString().contains('ssdt')) } if (remoteRepos) { logger.warn "WARNING: Remote repositories configured for $thisProject:\n" + remoteRepos.collect { "\t$it.name $it.url " }.join('\n') + "\n Moved to lowest priority..." remoteRepos.each { thisProject.repositories.remove(it) thisProject.repositories.addLast(it) } } logger.info "$thisProject configured repositories:\n" + thisProject.repositories.collect {"\t$it.name ${it.hasProperty('url') ? it.url : '' }" }.join('\n') if (thisProject.repositories.find { it.name == 'local' } && thisProject.getTasksByName('uploadArchives', false)) { uploadArchives { repositories { add thisProject.repositories.local } } thisProject.tasks.create("publishLocal") { description = "Publishes this projects artifacts to developer's local repository" dependsOn = ["uploadArchives"] } } } root.subprojects { p -> if (root.useIndy()) { println "enabling indy compilation on $p" [compileGroovy.groovyOptions, compileTestGroovy.groovyOptions]*.with { optimizationOptions = [indy: true] } } } } } task showEnvironments { doLast { println "Defined environments: $gradle.environments" gradle.environments.each { e -> println "\n $e:" gradle.getProperty(e).flatten().sort { it.key }.each { k, v -> println String.format(' %25s = %s', k, k.contains('password') ? "********" : v) } } if (logger.isInfoEnabled()) { println "System properties:" System.properties.each { println " $it" } println "env variables:" System.getenv().each { println " $it" } } } } def loadEnvironments() { def developerPrivate = new Properties() if (file('private.properties').exists()) { developerPrivate.load(file('private.properties').newReader()) } def envOverrides = [:] if (!hasProperty('env')) { gradle.ext.env = developerPrivate.env ?: 'dev' } else { def values = getProperty('env').split(',') gradle.ext.env = values.first() values.tail().each { def (k, v) = it.split('=') envOverrides.put(k, v) } } println "Environment is: $gradle.env ($envOverrides)" def slurper = new ConfigSlurper(gradle.env) slurper.setBinding(['gradle': gradle]) def environment = slurper.parse( '''deploy.mode="production" environments { test { deploy.mode="test" } dev { deploy.mode="development"} }''') if (developerPrivate['deploy.mode']) { environment.put('deploy.mode', developerPrivate['deploy.mode']) } environment.put('branchInfo',gradle.branch) environment.put('branchVersion',gradle.branch.version.toString()) def environments = [] gradle.ext.environment = environment file('.').listFiles().findAll { it.name ==~ /^environment.*\.groovy$/ }.sort { it.name }.each { envFile -> def envName = envFile.name - '.groovy' def privateFile = file("private" + envName - "environment" + ".groovy") logger.info("loading environment $envFile.name") def envCfg = slurper.parse(envFile.toURL()) envCfg.merge(slurper.parse(developerPrivate)) envCfg.put('ssdt.projectid', gradle.ssdtProjectId) envCfg.put('ssdt.environment', gradle.env) if (privateFile.exists()) { logger.info("loading private environment $privateFile") envCfg.merge(slurper.parse(privateFile.toURL())) } gradle.rootProject.getProperties().find { it.key.startsWith('environment') }.each { it.value.split(',').each { p -> def (k, v) = p.split('=') logger.info("$envName: overriding " + k + "=" + v + " in $it") envCfg.put(k, v) } } envOverrides.each { k, v -> logger.info("$envName: overriding " + k + "=" + v) envCfg.put(k, v) } environment.merge(envCfg) if (envName != 'environment') { gradle.ext[envName] = envCfg environments << envName } } environment.merge(slurper.parse(developerPrivate)) def deployMode = environment.deploy.mode ?: 'development' environments.each { gradle.ext[it].put('ssdt.deployment.mode', deployMode) } environments << 'environment' gradle.ext.environments = environments } def updateCopyrightProfile(Project r) { r.file('.idea/copyright').mkdirs() r.file('.idea/copyright/ODE.xml').text = '''<component name="CopyrightManager"> <copyright> <option name="notice" value="Copyright (c) &#36;today.year. Ohio Department of Education. - All Rights Reserved. Unauthorized copying of this file, in any medium, is strictly prohibited. Written by the State Software Development Team (http://ssdt.oecn.k12.oh.us/) " /> <option name="myName" value="ODE" /> </copyright> </component>''' r.file('.idea/copyright/profiles_settings.xml').text = '''<component name="CopyrightManager"> <settings default="ODE" /> </component>''' } @ToString(includeNames=true) class RuntimeInfo { // OS memory in megabytes, zero if unknown int systemMemory = 0 int systemFreeMemory = 0 String javaVersion = System.getProperty('java.version') RuntimeInfo() { try { new File('/proc/meminfo').readLines().findAll { it.startsWith 'Mem' }.collect { it.split(/\s+/) }.each { int value = (it[1] as Long) / 1024 if (it[0].startsWith('MemTotal')) { systemMemory = value } if (it[0].startsWith('MemFree')) { systemFreeMemory = value } } } catch (e) { } } void requireMemory(int megabytes) { if (systemFreeMemory > 0 && systemFreeMemory < megabytes) { println "WARNING: potentially insufficent OS memory for this build" // throw new GradleException("insufficent free OS memory for this build (available: ${systemFreeMemory}m, required: ${megabytes}m)") } } /** * Returns maximum memory available upto the value specified. */ int maxMemory(int megabytes) { if (systemFreeMemory) { [systemFreeMemory,megabytes].min() } else { megabytes } } void requireJava(String version) { if ( version && !javaVersion.startsWith(version)) { throw new GradleException("Requires java version $version but running under $javaVersion") } } } @TupleConstructor @Sortable class Version { Integer major = 0 Integer minor = 0 Integer patch = 0 Boolean snapshot = true Integer previousMinor = 0 Integer previousPatch = 0 Version nextMajor() { new Version(major + 1, 0, 0, false) } Version nextMinor() { if (snapshot) { new Version(major, minor , 0,false) } else { new Version(major, minor + 1, 0,false) } } Version nextPatch() { if (snapshot) { new Version(major, previousMinor, previousPatch + 1,false) } } Version nextSnapshot() { new Version(major, minor + 1, 0,true,minor,patch) } boolean isHotfix() { !snapshot && patch > 0 } String toString() { "${major}.${minor}.${patch}${snapshot ? '.SNAPSHOT' : ''}" } } void setBranchInfo() { gradle.ext.branch = new BranchInfo(System.getenv('bamboo_planRepository_branch')) gradle.ext.branchName = gradle.branch.name gradle.ext.branchStream = gradle.branch.stream gradle.ext.branchHash = gradle.branch.hash println "${gradle.hgRepositoryUrl} ${gradle.branch} ${gradle.branch.version}" } @ToString(includes=['name','shortName','buildVersion','imageId','deployName'],includeNames= true) class BranchInfo { def name def stream = "none" def buildNumber = "" def changeset = "" def version BranchInfo(name) { this.name = name if (!name) { this.name = determineName() ?: '' } this.name = this.name.replace('@', '-') determineStream() buildNumber = System.getenv('bamboo_buildNumber') ?: "" changeset = System.getenv('bamboo_planRepository_revision') ?: "" } String getDefaultDependencyStatus() { return isRelease() ? 'release' : 'integration' } private boolean isRelease() { return stream in ['release', 'hotfix'] } def getShortName() { def result = name.contains('/') ? name.split('/')[1] : name } String getBuildVersion() { def v = isRelease() ? shortName - "v": "" return v } def Version getVersion() { if (!version) { if (isRelease()) { version = new Version(*getBuildVersion().split('\\.')*.toInteger(), false) } else { version = findSnapshotVersion() } } return version } def getImageId() { (buildVersion ?: shortName.take(25)) + (buildNumber ? "-${buildNumber}" : "-0") } def getDeployName() { (buildVersion ?: shortName.take(25)).toLowerCase().collectReplacements { ('a'..'z').contains(it) || ('0'..'9').contains(it) || it == "-" ? null : '-' } } def getHash() { generateMD5(name) } def generateMD5(String s) { def digest = java.security.MessageDigest.getInstance("MD5") digest.update(s.bytes); new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0') } private findSnapshotVersion() { try { def repositoryUrl = System.getenv('bamboo_planRepository_repositoryUrl') if (repositoryUrl) { println "hg pull $repositoryUrl".execute().text } def versions = "hg branches --closed".execute().text.split('\n').findAll { it.startsWith( 'release') || it.startsWith( 'hotfix') }.collect { it.replaceAll('\\s+',' ').split(' ')[0].split('/')[1] - 'v' }.collect { new Version(*it.split('\\.')*.toInteger()) }.sort { v1, v2 -> v2 <=> v1 } return versions ? versions.first().nextSnapshot() : new Version().nextSnapshot() } catch (e) { return new Version().nextSnapshot() } } def determineName() { try { def branch = "hg branch".execute().text.trim() def rawParents = 'hg parents'.execute().text def parent = rawParents.split('\n').find { it.startsWith("branch") }?.split(":")?.getAt(1)?.trim() return parent ?: branch } catch (e) { ['.hg/branch', '../.hg/branch'].findResult { new File(it).exists() ? new File(it).text : null } } } void determineStream() { def flowConfig = new File('.hgflow').exists() ? new File('.hgflow') : new File('../.hgflow') if (flowConfig.exists()) { def flows = new Properties() flows.load(flowConfig.newReader()) flows.stringPropertyNames().each { if (!it.startsWith("[") && name.startsWith(flows.getProperty(it))) { stream = it } } } } }