version.gradle

import java.text.SimpleDateFormat

ext {
    jmeRevision     = 0
    jmeGitHash      = ""
    jmeGitTag       = ""
    jmeShortGitHash = ""
    jmeBuildDate    = new SimpleDateFormat("yyyy-MM-dd").format(new Date())
    jmeBranchName   = "unknown"
    jmeFullVersion  = "${jmeVersion}-SNAPSHOT"
    jmeVersionTag="SNAPSHOT"
}

def gitOutput = { List<String> args ->
    def output = providers.exec {
        commandLine(['git'] + args)
        ignoreExitValue = true
    }
    if (output.result.get().exitValue == 0) {
        return output.standardOutput.asText.get().trim()
    }
    return ""
}

def normalizeBranchName = { String branchName ->
    branchName && branchName != "HEAD" ? branchName : "unknown"
}

try {
        // Users can configure behavior by setting properties on the command
        // line:
        //
        // jmeVersionName:
        // If set this will override all automatic version detection.
        //
        // useCommitHashAsVersionName:
        // If there is no jmeVersionName set and the current commit has no
        // specific tag then setting this to 'true' will cause the version to
        // be the full commit ID.
        //
        // includeBranchInVersion:
        // Set to true if a non-master branch name should be included in the automatically
        // generated version.

        def revisionOutput = gitOutput(['rev-list', '--count', 'HEAD'])
        jmeRevision = revisionOutput ? revisionOutput.toInteger() : 0
        jmeGitHash = gitOutput(['rev-parse', 'HEAD'])
        jmeShortGitHash = gitOutput(['rev-parse', '--short=7', 'HEAD'])
        jmeBranchName = normalizeBranchName(gitOutput(['branch', '--show-current']) ?: gitOutput(['rev-parse', '--abbrev-ref', 'HEAD']))

        // This code will find an exact-match tag if the current
        // commit is the same as the tag commit.
        jmeGitTag = gitOutput(['describe', '--tags', '--exact-match', 'HEAD'])
        def latestTag;
        if( jmeGitTag ) {
            latestTag = jmeGitTag;
        } else {
            latestTag = gitOutput(['describe', '--tags', '--abbrev=0', 'HEAD'])
            println "Latest tag:" + latestTag
        }

        // We could enhance this with some more regex if we wanted to sanity
        // check that it was formatted like our versions.
        def tagVersion = latestTag ? latestTag.replaceFirst(/^v/, "") : jmeVersion;
        // If the branch is not master then use the tag.
        if( jmeBranchName != "master" && latestTag ) {
            jmeVersion = tagVersion
        }

        // Parse out just the base version part.  -SNAPSHOT versions
        // shouldn't really include our release suffixes
        def baseVersion = (jmeVersion =~/(\d+\.\d+.\d+)/)
        baseVersion = baseVersion.size() > 0 ? baseVersion[0][0] : jmeVersion

        if( !jmeVersionName ) {
            // If there is a specific tag for the top commit then we always
            // use that.
            if( jmeGitTag ) {
                println "Using GIT tag as version"
                jmeFullVersion = tagVersion; // already cleaned up
                jmeVersionTag = ""  // and no SNAPSHOT suffix for an exact version tag

                // Note: this will not automatically add SNAPSHOT if the user has
                // local changes that they haven't committed.  Technically, only
                // real CI builds should be using non-SNAPSHOT versions so we may
                // eventually want to change the script to always use -SNAPSHOT with
                // a CI option to turn it off.
                // We could also check for unstaged modified/removed files.
                //     def modCount = ...
                // ...but that seems like a wasteful check considering only official
                // version builds should not have a -SNAPSHOT.

            } else if( useCommitHashAsVersionName == "true" && jmeGitHash ) {
                // The user has opted to use the hash... and we actually have
                // a hash.
                println "Using commit ID as version"
                jmeFullVersion = jmeGitHash;
                jmeVersionTag = ""
            } else {
                println "Auto-detecting version"
                jmeVersionTag = "SNAPSHOT"

                if( includeBranchInVersion == "true" && jmeBranchName != "master" && jmeBranchName != "unknown" ) {
                    jmeFullVersion = baseVersion + "-" + jmeBranchName + "-" + jmeVersionTag;
                } else {
                    jmeFullVersion = baseVersion + "-" + jmeVersionTag;
                }
            }
        } else {
            // Just use defaults
            println "Using user-defined version"
            jmeFullVersion=jmeVersionName
            jmeVersionTag = "SNAPSHOT"
        }

        println("Revision: ${jmeRevision}")
        println("Hash: ${jmeGitHash}")
        println("Short Hash: ${jmeShortGitHash}")
        println("Tag: ${jmeGitTag}")
        println("Build Date: ${jmeBuildDate}")
        println("Build Branch: ${jmeBranchName}")
        println("Use commit hash as version ${useCommitHashAsVersionName}")
        println("Base Version: ${baseVersion}")
        println("Build Suffix: ${jmeVersionTag}")
        println("Build Version: ${jmeFullVersion}")

} catch (ex) {
    // Failed to get repo info
    logger.warn("Failed to get repository info: " + ex.message + ". " + \
                "Only partial build info will be generated.")
}