build.gradle

/*
 * Copyright 2017 Rundeck, Inc. (http://rundeck.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.regex.Matcher

buildscript {
    repositories {
        jcenter()
    }

    dependencies {
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
    }
}
plugins {
    id 'pl.allegro.tech.build.axion-release' version '1.9.3'

    id 'maven-publish'
}
ext.githubUrl = "https://github.com/rundeck/rundeck-cli"
ext.changelogFile = file("CHANGELOG.md")

/**
 * Unreleased changes list from the changelog file
 * @param prevVersion
 * @param changelog
 * @return
 */
def unreleasedLog(prevVersion, changelog) {
    def m = changelog?.text =~ ~/(?si)^(## unreleased(.*))## ${prevVersion}.*$/
    if (m.find()) {
        return m.group(2)?.split(/\n/).findAll { it }.collect { it.replaceAll(/^[\*-]\s*/, '') }
    }
}

/**
 * Generate partial or full changelog
 * @param prevTag
 * @param baseUrl
 * @param curVersion
 * @param prevVersion
 * @param changelog
 * @param full
 * @return
 */
def genChangelog(prevTag, baseUrl, curVersion, prevVersion, File changelog, full = false) {
    def diff = "${prevTag}..."
    def serr = new StringBuilder(), sout = new StringBuilder()
    def proc = ['git', 'log', '--no-merges','--pretty=format:%s', diff].execute()
    proc.consumeProcessOutput(sout, serr)
    proc.waitForOrKill(1000)
    def logs = sout.toString().readLines()
    def include = [~/.*[fF]ix(e[sd])? #\d+.*/, ~/^[fF]ix(e[sd])?:.*/, ~/^[lL]og:?.*/]

    def unrel = changelog ? unreleasedLog(prevVersion, changelog) ?: [] : []

    unrel.addAll(logs.findAll { t -> t && include.any { t ==~ it } })
    logs = unrel.
            collect { '* ' + it.replaceAll(/^[lL]og:\s+/,'').replaceAll(/(#(\d+))/, "[Issue \$1]($baseUrl/issues/\$2)") }.
            join('\n')
    logs = logs ? logs + '\n' : ''
    if (full && changelog) {
        def text = """## ${curVersion}

$logs
[Changes]($baseUrl/compare/${diff}v${curVersion})

"""
        return changelog.text.replaceAll(
                ~/(?s)^(## unreleased(.*))?(## ${prevVersion}.*)$/,
                Matcher.quoteReplacement(text) + '$3'
        )
    }
    return logs
}

scmVersion {
    tag {
        prefix = 'v'
        versionSeparator = ''
    }
    hooks {
        pre 'fileUpdate', [file       : 'docs/_config.yml',
                           pattern    : { v, c -> /app_version: [^\s]+/ },
                           replacement: { v, c -> "app_version: $v" }]
        pre 'fileUpdate', [file       : 'rd-cli-tool/src/main/resources/rd-banner.txt',
                           pattern    : { v, c -> /\(v$v\)/ },
                           replacement: { v, c -> "(v$v)" }]
        pre { context ->
            def changelog = changelogFile
            def changes = file('docs/changes.md')
            def changest = file('docs/_changes.md')
            def newtext = genChangelog(
                    "v${context.previousVersion}",
                    githubUrl,
                    context.currentVersion,
                    context.previousVersion,
                    changelog,
                    true
            )
            changelog.text = newtext
            changes.text = changest.text + newtext

            context.addCommitPattern('docs/changes.md')
            context.addCommitPattern('CHANGELOG.md')
        }
        pre 'commit'
    }
}

allprojects {
    project.version = scmVersion.version
    ext.rpmVersion=project.version.replaceAll('-', '.')

    repositories {
        mavenLocal()
        jcenter()
        mavenCentral()
    }
}

ext.axionContext=
    pl.allegro.tech.build.axion.release.infrastructure.di.GradleAwareContext.create(project, project.scmVersion)


def getAxionVersion = {
    def rules = axionContext.rules
    axionContext.versionService()
    scmVersion.versionService.currentVersion(
        rules.version,
        rules.tag,
        rules.nextVersion
    )
}

def getPreviousTag = {
    def rules = axionContext.rules
    def curVersion = getAxionVersion()
    rules.tag.serialize(rules.tag, curVersion.previousVersion.toString())
}

task previousVersion(){
    doLast {
        println "Previous version: ${getAxionVersion().previousVersion}"
        println "Previous tag: ${getPreviousTag()}"
    }
}
task changeLog(){
    doLast {
        def version = getAxionVersion()
        def prevTag = getPreviousTag()
        println genChangelog(
                prevTag,
                githubUrl,
                version.version,
                version.previousVersion,
                changelogFile,
                project.hasProperty("changelogFull")
        )
    }
}