build.gradle

/*
 * This project requires ablunit to 'test', along with corelib for runtime and compile-time
 */

import com.progress.gradle.abl.tasks.*
import com.progress.gradle.abl.*
import java.time.*
import groovy.io.*
import groovy.json.*

plugins {
    id 'progress.openedge.abl-base' version '2.3.0'
    id "base"
}

group = 'com.openedge.injectabl'

/**
* Please makes sure you set this in your environment before beginning this build
*/
String dlc = System.getenv('DLC')
if (dlc == null ) {dlc = (project.hasProperty('dlc') ? project.property('dlc') : null)}

// Determine the compiler options
// one or more of req-ret-val, req-full-kw, req-full-name, req-fld-qual can be used, in a comma-delimited value
String[] ablCompOpts = (project.hasProperty('ablCompilerOpts') ? project.property('ablCompilerOpts') : '').split(',')

// Global debug flag
Boolean dbgProp = (project.hasProperty('dbg') ? project.property('dbg') : 'false').toBoolean()

def libSrcPaths = []

// Should be in abl.pctTaskArgs but it has to be created first, otherwise we get a 'null' error
// the dir is created in ResolveOpenEdgeDependancies.doFirst
File avmTempDir = file("${buildDir}/temp")

// Doc at https://docs.progress.com/bundle/openedge-devops-framework/page/ABLExtension.html
abl {
    rcodeDir = file("${buildDir}/rcode")      // is the default; may not be needed
    avmOptions {
        tty.enabled='true'
        startupParameters='-cpinternal UTF-8'
        tmpDir=avmTempDir.path
    }
    compileOptions {
        multiCompile.enabled=true
        xref.enabled = true
        xrefXml.enabled=true
        strictOptions.requireReturnValues    = '' //ablCompOpts.contains('req-ret-val')
        strictOptions.requireFullKeywords    = '' //ablCompOpts.contains('req-full-kw')
        strictOptions.requireFullNames       = '' //ablCompOpts.contains('req-full-names')
        strictOptions.requireFieldQualifiers = '' //ablCompOpts.contains('req-fld-qual')
    }
}

// dependency repo setup
repositories {
    mavenCentral()
}

task initBuildDir (){
    delete("${buildDir}/resources")
}
task extractCorelibPl(type: ExtractPL){
    from("${abl.dlcHome}/src/OpenEdge.Core.pl")
    into("${buildDir}/dlc-src/")
    arguments = [ dirmode:"0777", encoding  : 'undefined' ]
}

task extractSources() {
    dependsOn extractCorelibPl

    libSrcPaths << "${buildDir}/dlc-src/"
}
task ResolveOpenEdgeDependancies(){
    dependsOn extractSources
    doFirst() {
        avmTempDir.mkdirs()
    }
}
task createManifest(type: ABLRun){
    dependsOn ResolveOpenEdgeDependancies

    outputs.file("${buildDir}/MANIFEST.MF")

    procedure      = 'bitness.p'
    wrkDir         = "${buildDir}"
    propath        = files('src/main/resources')
    arguments      = [noErrorOnQuit: 'true',
                      resultProperty: 'bitness',
                      debugPCT: dbgProp,
                      failOnError: 'false' ]

    // Need to doLast so that we have the OE version
    doLast {
        // resolving this here means that the Ant manifest task behaves
        def oeVer = "${abl.openedgeVersion}"

        ant.manifest(file: file("${buildDir}/MANIFEST.MF")) {
            ant.attribute( name: "Build-Date", value: OffsetDateTime.now( ZoneOffset.UTC ).format("yyyy-MM-dd'T'HH:mm:ss.SSSX"))
            ant.attribute( name: "Build-OS",   value: System.getProperty('os.name') + " " + System.getProperty('os.arch') + " " + System.getProperty('os.version'))

            ant.section(name: "InjectABL") {
                ant.attribute( name:"InjectABL-Version",     value:"${version}")
                ant.attribute( name:"InjectABL-Description", value:'OpenEdge InjectABL Library')
                ant.attribute( name:"Package-Type",          value:"\${packageType}")
            }
            ant.section(name: "OpenEdge") {
                ant.attribute( name:"DLC-Version",        value:"${abl.openedgeVersion}")
                ant.attribute( name:"DLC-Bitness",        value:"${ant.bitness}")
            }
        }
    }
}
// this task creates the source pl file
task packageSourceCode(type: Zip){
    dependsOn createManifest

    destinationDirectory = file("${buildDir}/dist/")
    archiveBaseName = "${rootProject.name}"
    archiveClassifier = "sources"
    archiveVersion = "${version}"
    archiveExtension = "zip"

    from('src/main/abl', "${buildDir}/MANIFEST.MF")

    expand(packageType: "sources")
    include("**/*")
    exclude("**/*.r")
}
task createPF(type: Copy) {
    outputs.file("${buildDir}/resources/main/build.pf")
    outputs.file("${buildDir}/resources/test/build.pf")
    outputs.file("${buildDir}/resources/test/run.pf")

    // in case there are any params passed in and also in the PF
    String params = project.hasProperty('ablStartupParams') ? project.property('ablStartupParams') : '#none'

    // this "into"'s are relative to the main "into" below
    from("src/main/resources") { into "main" }
    from("src/test/resources") { into "test" }
    include "*.pf"
    into "${buildDir}/resources"
    expand(startupParams: params,
           projectDir:    project.projectDir,
           buildDir:      "${buildDir}"        )

    filePermissions {
        unix('rwxrwxr--')
    }
    dirPermissions {
        unix('rwxrwxr--')
    }
}
// this task compiles the TEST code to verify there are no compiler errors
task compileTest(type: ABLCompile) {
    dependsOn ResolveOpenEdgeDependancies
    dependsOn createPF

    outputs.dir("${buildDir}/tests")
    //outputs.file("${buildDir}/temp/compileTest-result.json")

    avmOptions {
        parameterFile  = file("${buildDir}/resources/test/build.pf").absolutePath
        tmpDir  = avmTempDir.path
    }
    compileOptions {
        outputType = 'json'
        multiCompile.enabled=true
        xrefDir = "${buildDir}/tests"
    }

    rcodeDir = file("${buildDir}/tests").path
    include('**/*.cls')
    include('**/*.p')
    source('src/test/abl')
    arguments = [debugPCT: dbgProp]

    doFirst {
        // set propath here since we only know the source paths at runtime, not evaluation time
        propath = files('src/test/abl',
                        'src/main/abl',
                        libSrcPaths)
    }
    doLast() {
        logWarnings(file("$buildDir/tests/.pct/"), "compileTest")
    }
}
// write compiler warning to the build log
def logWarnings(File pctDir, String logGrp) {
    pctDir.traverse(type: FileType.FILES, nameFilter: ~/.*\.warnings/ )
        { logger.warn("[:$logGrp] " + it.text.trim()) }
}
// This task compiles all the source code
task compileCode(type: ABLCompile) {
    dependsOn ResolveOpenEdgeDependancies
    dependsOn createPF

    outputs.dir("${abl.rcodeDir}/OpenEdge/InjectABL")
    outputs.file("${buildDir}/temp/compileCode-result.json")

    avmOptions {
        parameterFile  = file("${buildDir}/resources/main/build.pf").absolutePath
        tmpDir  = avmTempDir.path
    }

    // we use preprocessed files for doc
    compileOptions {
        preprocess.enabled = true
        preprocessDir = "${buildDir}/preprocess"
        outputType = 'json'
        strictOptions.requireFullNames = 'error'
        strictOptions.requireFieldQualifiers ='error'
        strictOptions.requireFullKeywords ='error'
        strictOptions.requireReturnValues ='error'
    }

    rcodeDir = abl.rcodeDir       // in theory, can leave this to the default; in practice, not
    source('src/main/abl')

    include('**/*.cls')
    include('**/*.p')

    doFirst {
        // set the propath here, not in the evaluation phase, because the
        // source PLs are only unzipped now
        propath = files('src/main/abl',
                        libSrcPaths)
    }
    doLast {
        logWarnings(file("$buildDir/rcode/.pct/"), "compileCode")
    }
}
// This task creates the rcode procedure library along with the manifest file
task packageCode(type: PL){
    dependsOn compileCode
    dependsOn createManifest

    inputs.file("${buildDir}/MANIFEST.MF")
    inputs.dir("${abl.rcodeDir}/OpenEdge/InjectABL")
    outputs.file("${buildDir}/dist/${rootProject.name}-${version}-tty.pl")

    plFile = "${buildDir}/dist/${rootProject.name}-${version}-tty.pl"

    // the compiler adds r-code for classes that aren't part of this package, so we
    // need to be explicit about what we include
    from("${buildDir}/rcode" , 'MANIFEST.MF')
    include('**/*.r', 'MANIFEST.MF')

    codepage = 'undefined'
    arguments = [encoding: 'undefined' ]

    doFirst {
        copy {
            from "${buildDir}/MANIFEST.MF"
            into abl.rcodeDir
            expand(packageType: 'tty')
        }
    }
}
task ablTest(type: ABLUnit) {
    dependsOn createPF
    dependsOn packageCode
    dependsOn compileTest

    source('src/test/abl')

    inputs.file("${buildDir}/dist/${rootProject.name}-${version}-tty.pl")
    outputs.file('results.xml')

    //outputDir does not work on Linux, per https://docs.progress.com/bundle/openedge-devops-framework/page/ABLUnit.html

    profiler {
        enabled = true
        coverage = true
        outputDir = "${buildDir}/profiler"
    }

    arguments = [noErrorOnQuit: true,
                 failOnError: false,
                 debugPCT: dbgProp,
                 cpInternal: 'UTF-8',
                 cpStream:'UTF-8',
                 writeLog: 'false']

    avmOptions {
        tmpDir = avmTempDir.path
        parameterFile = "${buildDir}/resources/test/run.pf"
    }

    doFirst() {
        // set propath here since we only know the source paths at runtime, not evaluation time
        propath = files("src/test/abl",                                             // for other non-code artifacts needed by the tests
                        libSrcPaths,                                                // other dependencies
                        "${buildDir}/dist/${rootProject.name}-${version}-tty.pl"    // project rcode being tested
                        )
    }

    doLast() {
        // No native Gradle move-file task exists
        ant.move(file:'results.xml', todir: "${buildDir}/tests/")

        if (!file("${buildDir}/tests/results.xml").exists() ) {
            throw new GradleException("ABLUnit results file ${buildDir}/tests/results.xml not found")
        }
        def results = new XmlSlurper().parse( file("${buildDir}/tests/results.xml"))
        logger.info("***** TEST RESULTS: ${buildDir}/tests/results.xml: tests=${results.@tests}; errors=${results.@errors}; failures=${results.@failures}; skipped=${results.@skipped}")
    }
}

defaultTasks 'packageSourceCode', 'packageCode', 'ablTest'