build.gradle

plugins {
	id 'com.moowork.node' version '1.2.0'
	id 'net.researchgate.release' version '2.4.0'
}

node {
	version = '6.11.2'
	npmVersion = '3.10.10'
	workDir file("rcp/org.testeditor.web.testexecutionlogview/node")
	download = true
}

def targetPlatform = "$projectDir/target-platform"

task npmInstallDep(type: NpmTask, dependsOn: npmSetup){
	group 'Node'
	workingDir file("rcp/org.testeditor.web.testexecutionlogview")
	description 'Installs the NodeJS packages'
    args = [ 'install' ]    
}

task npmInstallTeLogView(type: NpmTask, dependsOn: npmInstallDep) {
	group 'Node'
	workingDir file("rcp/org.testeditor.web.testexecutionlogview")
	description 'Typescript compile'
	args = [ 'run-script', 'tsc' ]
}

task copyTeLogViewToRcp(type: Copy, dependsOn: npmInstallTeLogView) {
    from 'rcp/org.testeditor.web.testexecutionlogview'
    into 'rcp/org.testeditor.rcp4.views.tcltestrun/web-app'
    exclude 'node'
    exclude 'typings'
    exclude 'pom.xml'
    exclude 'package.json'
}

task preBuildWeb(dependsOn: [copyTeLogViewToRcp]) {
    
}

task buildTarget(type: MavenExec) {
    inputs.files fileTree(dir: targetPlatform, exclude: '**/target/**')
    outputs.dir file("$targetPlatform/org.testeditor.releng.target.updatesite/target/site")
    workingDir targetPlatform
    args 'clean', 'verify'
}

task cleanTarget(type: MavenExec) {
    workingDir targetPlatform
    args 'clean'
}

task assemble() {
}

// TODO define inputs and outputs
task build(type: MavenExec, dependsOn: buildTarget) {
    def branch = getBranchName();
    def profileParameter = '';
    if (branch.startsWith('develop') || branch.startsWith('master')) {
        profileParameter = '-Prcp,product'
    }
    workingDir projectDir
    args 'clean', 'install', '-Dsurefire.useFile=false', '-Dtycho.localArtifacts=ignore', profileParameter
}

task deploy(type: MavenExec) {
    workingDir projectDir
    args 'deploy', '-DskipTests', '-Dtycho.localArtifacts=ignore'
}

// TODO should be dependent on build (but build needs to be incremental for that)
task buildProduct(type: MavenExec) {
    workingDir projectDir
    args 'package' , '-Pproduct,rcp', '-DskipTests', '-Dtycho.localArtifacts=ignore'
}

task updateTargetVersion(type: MavenExec) {
    workingDir targetPlatform
    args 'org.eclipse.tycho:tycho-versions-plugin:set-version',
        '-Dtycho.mode=maven', '-Dartifacts=org.testeditor.releng.target.parent',
        "-DnewVersion=$project.version"
}

task updateMvnVersion(type: MavenExec) {
    workingDir projectDir
    args 'org.eclipse.tycho:tycho-versions-plugin:set-version',
        '-Dtycho.mode=maven', '-Dartifacts=org.testeditor.releng.parent',
        "-DnewVersion=$project.version"
}

task updateTargetVersionAfterVersionUpdate(type: MavenExec) {
    workingDir targetPlatform
    doFirst {
        args 'org.eclipse.tycho:tycho-versions-plugin:set-version',
             '-Dtycho.mode=maven', '-Dartifacts=org.testeditor.releng.target.parent',
             "-DnewVersion=$project.version"
    }
}

task updateMvnVersionAfterVersionUpdate(type: MavenExec) {
    workingDir projectDir
    doFirst {
        args 'org.eclipse.tycho:tycho-versions-plugin:set-version',
             '-Dtycho.mode=maven', '-Dartifacts=org.testeditor.releng.parent',
             "-DnewVersion=$project.version"
    }
}

task readProjectVersion {
    doLast {
        def props = new Properties()
        new File("gradle.properties").withInputStream {
            stream -> props.load(stream)
        }
        println("got new project version ${props.get('version')}")
        project.version =  props.get('version')
        println("project.version=$project.version")
    }
}

readProjectVersion.shouldRunAfter(updateVersion)

updateMvnVersionAfterVersionUpdate.dependsOn(readProjectVersion)
updateTargetVersionAfterVersionUpdate.dependsOn(readProjectVersion)

beforeReleaseBuild.dependsOn(updateTargetVersion, updateMvnVersion)
commitNewVersion.dependsOn(updateTargetVersionAfterVersionUpdate, updateMvnVersionAfterVersionUpdate)

release {
    preTagCommitMessage = '[release]'
    tagCommitMessage = '[release]'
    newVersionCommitMessage = '[release] new version'
    tagTemplate = 'v${version}'
    buildTasks = []
}

/**
 * Rail-road diagram stuff below.
 */

def rrdAntlr4 = "rrd-antlr4-0.1.2.jar"

def String buildNestedParenthesisRegex(int level) {
    def preParen = "(?<!')\\(" // opening braces ( must not be preceeded by a ' to avoid string constant matching
    def postParen = "\\)" // closing braces
    def anyNonParenthesis = "[^()]*(('\\(')[^()]*)?" // may hold '(' as an exception to that rule, since this constant appears once in a while in the grammar

    def result  = preParen + anyNonParenthesis + postParen
    for(int i; i<level; i++) {
        result = preParen+"("+anyNonParenthesis+result+")*"+anyNonParenthesis+postParen
    }
    return result
}

def String convertToAntlr4(String antlr3) {
    def newContent = antlr3
    .replaceAll("(?<!')\\{[^{}]*\\}\\??(?<!')=>","") // replace all code prefix expression
    .replaceAll(buildNestedParenthesisRegex(7)+"[^()]*\\??(?<!')=>","") // remove all grammar prefix expressions

    def index=newContent.indexOf('entryRule')

    def codeRemoved = newContent.substring(0,index)+
        newContent.substring(index)
        .replaceAll("finally[ \t\n\r]*\\{[^{}]*\\}","") // finally code block after rule
        .replaceAll("@init","") // init code block
        .replaceAll("@after","") // after code block
        .replaceAll("(?<!')\\([ \t\r\n]*\\)","") // empty block of parenthesis
        .replaceAll("(?<!')\\{(?!')[^{}]*\\}","") // code block
        .replaceAll("(?<!')\\{(?!')[^{}]*\\}","") // code block (get the outer ones, too)
        .replaceAll("~\\((\\([^()]+\\))\\)",'~$1') // negation with double parenthesis (antlr4 wants one)
        .replaceAll("entryRule[^;]*;", "") // remove all entry rules up to next rule definition
        .replaceAll("(?<!')\\([ \t\r\n]*\\)","") // remove empty block of parenthesis
        // --- the following two rules reduce the length of each rule name but will result in different graphics
        //     the rrd-antlr4 converter seems to detect rules by having the prefix 'rule'
        .replaceAll("rule(?=[A-Z])", '') // remove preceeding rule before every syntax rule name
        .replaceAll("returns[ ]*\\[[^\\]]*\\]", "") // remove returning commands of each rule (

    return codeRemoved
}

// TODO should be dependent on build (but build needs to be incremental for that)
task buildAntlr4Grammars {
    description = "convert grammars of all language from antlr3 to (a reduced) antlr4 format"
    group = "Documentation"
    doFirst {
        println "generate reduced grammar"
    }
    doLast {
        println "Aml grammar"
        def amlFileContents = new File("${projectDir}/aml/org.testeditor.aml.dsl/src-gen/org/testeditor/aml/dsl/parser/antlr/internal/InternalAml.g").getText('UTF-8')
        println "Lines read " + amlFileContents.count('\n').toString()
        new File("${projectDir}/docs/application-modelling-language.g4").write(convertToAntlr4(amlFileContents))

        println "Tsl Grammar"
        def tslFileContents = new File("${projectDir}/tsl/org.testeditor.tsl.dsl/src-gen/org/testeditor/tsl/dsl/parser/antlr/internal/InternalTsl.g").getText('UTF-8')
        println "Lines read: " + tslFileContents.count('\n').toString()
        new File("${projectDir}/docs/test-specification-language.g4").write(convertToAntlr4(tslFileContents))

        println "Tcl grammar"
        def tclFileContents = new File("${projectDir}/tcl/org.testeditor.tcl.dsl/src-gen/org/testeditor/tcl/dsl/parser/antlr/internal/InternalTcl.g").getText('UTF-8')
        println "Lines read: " + tclFileContents.count('\n').toString()
        new File("${projectDir}/docs/test-case-language.g4").write(convertToAntlr4(tclFileContents))
    }
    doLast {
        println "generation finished."
        def tclg4textLines = new File("${projectDir}/docs/test-case-language.g4").getText('UTF-8').count('\n')
        println "Tcl grammar contains: ${tclg4textLines} lines"
        def tslg4textLines = new File("${projectDir}/docs/test-specification-language.g4").getText('UTF-8').count('\n')
        println "Tsl grammar contains: ${tslg4textLines} lines"
        def amlg4textLines = new File("${projectDir}/docs/application-modelling-language.g4").getText('UTF-8').count('\n')
        println "Aml grammar contains: ${amlg4textLines} lines"
    }
}

task createAmlRRD(type: JavaExec) {
    dependsOn(buildAntlr4Grammars)
    description = "create rail road syntax diagrams for application modelling language"
    group = "Documentation"
    main = "-jar"
    workingDir = "${projectDir}/docs"
    args (
        rrdAntlr4,
        "application-modelling-language.g4"
    )
}

task createTslRRD(type: JavaExec) {
    dependsOn(buildAntlr4Grammars)
    description = "create rail road syntax diagrams for test specification language"
    group = "Documentation"
    main = "-jar"
    workingDir = "${projectDir}/docs"
    args (
        rrdAntlr4,
        "test-specification-language.g4"
    )
}

task createTclRRD(type: JavaExec) {
    dependsOn(buildAntlr4Grammars)
    description = "create rail road syntax diagrams for test case language"
    group = "Documentation"
    main = "-jar"
    workingDir = "${projectDir}/docs"
    args (
        rrdAntlr4,
        "test-case-language.g4"
    )
}

task createAllRRDs {
    dependsOn(createAmlRRD,createTslRRD,createTclRRD)
    description = "create rail road syntax diagrams for all languages (Aml, Tsl, Tcl)"
    group = "Documentation"
}

def String getBranchName() {
    def branch = ""
    def proc = "git rev-parse --abbrev-ref HEAD".execute()
    proc.in.eachLine { line -> branch = line }
    proc.err.eachLine { line -> println line }
    proc.waitFor()
    return branch
}

/**
 * Prefills the commandLine with the Maven executable.
 */
class MavenExec extends Exec {
    
    MavenExec() {
        super()
        def isWindows = org.gradle.internal.os.OperatingSystem.current().windows
        if (isWindows) {
            commandLine 'cmd', '/c', 'mvn'
        } else {
            commandLine 'mvn'
        }
    }
    
}