build.gradle

buildscript {
    repositories {
        if (System.getenv('CI') != null) {
            maven {
                url = uri("https://itemis.blackstardlb.nl")
            }
        } else {
            maven {
                url = uri("https://projects.itemis.de/nexus/content/repositories/mbeddr")
            }
        }
        mavenCentral()
    }
    dependencies {
        classpath "de.itemis.mps:mps-gradle-plugin:$mps_gradle_plugin_version"
        classpath "dom4j:dom4j:1.6.1"
        classpath "jaxen:jaxen:1.2.0"
    }
}

plugins {
    id "com.github.node-gradle.node" version "2.2.3"
    id "java"
    id "download-jbr"
    id "net.ossindex.audit" version "0.4.11"
    id 'com.cosminpolifronie.gradle.plantuml' version '1.6.0'
}

group 'org.discipl'
version '1.0-SNAPSHOT'

ext {
    codeDir = project("code").projectDir
    ideDir = new File(project("code").buildDir, "artifacts/FlintIdeDistribution")
    linuxIdeDir = new File(ideDir, "linux")
    libDir = new File(codeDir, "solutions/Flint.runtime/libs")
    reportsDir = new File(project("code").buildDir, "reports")
    platformLibDir = new File(rootDir, "platform-libs")
    artifactDir = new File(rootDir, "artifacts")
    mpsDir = new File(buildDir, "mps")
    jbrsDir = new File(mpsDir, "jbrs")
    resourcesDir = new File(rootDir, "static-resources")
    generatedResourcesDir = new File(resourcesDir, "generated")
    platforms = ["linux", "mac", "win"]
    current_platform = currentPlatform()

    testFileName = "TEST-jetbrains.mps.testbench.junit.suites.AntModuleTestSuite0-execution.xml"
    flint_filler_release_version = "v0.0.5"
    flint_filler_executables_dir = new File(generatedResourcesDir, "flintfiller")

    javafx_version = "14"
    mbeddr_version = "2021.2.+"
    mps_version = "2021.2.5"
    node_version = "13.6.0"
    npm_version = "6.13.4"
    koin_version = "3.2.0-beta-1"
    ktor_version = "2.0.2"
    gson_version = "2.8.6"
    jbr_version = "11_0_6-b520.66"
    osx_jdk_version = "11.0.11-9"
}

configurations {
    mpslib
    mpsplatformlib
    mpsGenLib
    artifact
    mps
    antLib
}

repositories {
    mavenLocal()
    mavenCentral()
    maven { url = uri("https://jcenter.bintray.com/") }
    maven { url = uri("https://artifacts.metaborg.org/content/repositories/releases/") }
    if (System.getenv('CI') != null) {
        maven {
            url = uri("https://itemis.blackstardlb.nl")
        }
    } else {
        maven {
            url = uri("https://projects.itemis.de/nexus/content/repositories/mbeddr")
        }
    }
}

if (System.getenv('CI') == null) {
    def propertiesFile = file("local.properties")
    if (!propertiesFile.exists()) {
        logger.warn("No local.properties file found")
    } else {
        def props = new Properties()
        propertiesFile.withInputStream { props.load(it) }
        ext {
            ossindexUser = props.get("ossindexUser")
            ossindexToken = props.get("ossindexToken")
        }
        audit {
            user = "$ossindexUser"
            token = "$ossindexToken"
        }
    }
}

downloadJbr {
    jbrVersion = jbr_version
    downloadDir = mpsDir
}

dependencies {
    platforms.each { platform ->
        mpsplatformlib "org.openjfx:javafx-base:$javafx_version:$platform"
        mpsplatformlib "org.openjfx:javafx-controls:$javafx_version:$platform"
        mpsplatformlib "org.openjfx:javafx-graphics:$javafx_version:$platform"
        mpsplatformlib "org.openjfx:javafx-media:$javafx_version:$platform"
        mpsplatformlib "org.openjfx:javafx-swing:$javafx_version:$platform"
        mpsplatformlib "org.openjfx:javafx-web:$javafx_version:$platform"
    }

    mpslib(project("code:java:FlintParser")) {
        exclude group: 'org.openjfx'
    }
    mpslib(project("code:java:FlintSources")) {
        exclude group: "org.slf4j"
        exclude group: "junit"
    }
    mpslib('com.googlecode.json-simple:json-simple:1.1.1') {
        exclude group: "junit"
    }
    mpslib('commons-io:commons-io:2.11.0')
    mpslib('commons-codec:commons-codec:1.15')

    artifact "com.mbeddr:platform:$mbeddr_version"
    mps("com.jetbrains:mps:$mps_version")
    antLib('org.apache.ant:ant-junit:1.10.12')

    mpsGenLib "org.openjfx:javafx-base:$javafx_version:$current_platform"
    mpsGenLib "org.openjfx:javafx-controls:$javafx_version:$current_platform"
    mpsGenLib "org.openjfx:javafx-graphics:$javafx_version:$current_platform"
    mpsGenLib "org.openjfx:javafx-media:$javafx_version:$current_platform"
    mpsGenLib "org.openjfx:javafx-swing:$javafx_version:$current_platform"
    mpsGenLib "org.openjfx:javafx-web:$javafx_version:$current_platform"
}

if (!OperatingSystem.current().isMacOsX()) {
    ext["itemis.mps.gradle.ant.defaultJavaExecutable"] = new File(mpsDir, "jbr/bin/java")
}
ext["itemis.mps.gradle.ant.defaultScriptArgs"] = ["-Dmps_home=$mpsDir.path".toString()]
ext["itemis.mps.gradle.ant.defaultScriptClasspath"] = files("$mpsDir/lib/ant/lib/ant.jar", "$mpsDir/lib/ant/lib/ant-junit.jar", "$mpsDir/lib/ant/lib/ant-launcher.jar")

node {
    // Version of node to use.
    version = node_version

    // Version of npm to use.
    npmVersion = npm_version

    // Base URL for fetching node distributions (change if you have a mirror).
    distBaseUrl = 'https://nodejs.org/dist'

    // If true, it will download node using above parameters.
    // If false, it will try to use globally installed node.
    download = true

    // Set the work directory for unpacking node
    workDir = file("${project.buildDir}/nodejs")

    // Set the work directory for NPM
    npmWorkDir = file("${project.buildDir}/npm")

    // Set the work directory where node_modules should be located
    nodeModulesDir = file("${project.projectDir}")
}

task copyProjectLibs(type: Copy) {
    subprojects.forEach { sub ->
        from {
            new File(sub.buildDir, "libs")
        }
    }
    finalizedBy("addMpsLibsToFlintRuntime")
    into libDir
    rename '(.*)-[0-9]+\\..*', '$1.jar'
}

subprojects.forEach {
    copyProjectLibs.dependsOn it.getTasksByName("build", false)
}

task addMpsLibsToFlintRuntime() {
    doFirst {
        def libs = libDir.listFiles().collect { it.name }
        libs.sort(String.CASE_INSENSITIVE_ORDER)
        def file = file("$codeDir/solutions/Flint.runtime/Flint.runtime.msd")
        def reader = new org.dom4j.io.SAXReader()
        def document = reader.read(file)
        def solution = (org.dom4j.Element) document.selectSingleNode("/solution")

        def stubModelEntries = (org.dom4j.Element) solution.selectSingleNode("stubModelEntries")
        stubModelEntries.selectNodes("stubModelEntry").each {
            if (it instanceof org.dom4j.Element) {
                ((org.dom4j.Element) it).detach()
            }
        }

        def javaModelRoots = (org.dom4j.Element) solution.selectSingleNode("models/modelRoot[@type='java_classes']")
        javaModelRoots.selectNodes("sourceRoot").each {
            if (it instanceof org.dom4j.Element) {
                ((org.dom4j.Element) it).detach()
            }
        }
        libs.each {
            javaModelRoots.addElement("sourceRoot").addAttribute("location", it)
            stubModelEntries.addElement("stubModelEntry").addAttribute("path", "\${module}/libs/" + it)
        }


        def lineSeperator = "\n"
        if (OperatingSystem.current().isWindows()) {
            lineSeperator = "\r\n"
        }
        def format = OutputFormat.createPrettyPrint()
        format.setNewLineAfterDeclaration(false)
        format.setLineSeparator(lineSeperator)
        format.setPadText(false)
        org.dom4j.io.XMLWriter writer = new org.dom4j.io.XMLWriter(new FileWriter(file), format)
        writer.write(document)
        writer.close()

        def fixedText = file.getText().replace("/>", " />") + lineSeperator
        file.write(fixedText)
    }
}

task cleanLibs(type: Delete) {
    delete(libDir)
}

task resolveLibs(type: Copy) {
    group "dependancies"
    dependsOn cleanLibs
    from {
        configurations.mpslib.resolve()
    }
    into libDir
    finalizedBy copyProjectLibs
    rename '(.*)-[0-9]+\\..*.', '$1.jar'
}

task cleanResources(type: Delete) {
    delete fileTree(dir: "$generatedResourcesDir", exclude: "**/flintfiller/*")
}

task fetchComplianceByDesign(type: Copy) {
    dependsOn npmInstall
    from "$rootDir.path/node_modules/@discipl/compliance-by-design/build"
    into "${generatedResourcesDir.path}/compliance-by-design"
}

task fetchResources() {
    group "dependancies"
    dependsOn cleanResources
    finalizedBy fetchComplianceByDesign
    finalizedBy "fetchFlintFillerExecutables"
}

task cleanPlatformLibs(type: Delete) {
    delete(platformLibDir)
}

task resolvePlatformLibs(type: Copy) {
    group "dependancies"
    dependsOn cleanPlatformLibs
    from configurations.mpsplatformlib.resolve()
    into platformLibDir
    rename '(.*)-[0-9]+\\..*.', '$1.jar'
}

task unzipArtifacts() {
    doFirst {
        copy {
            artifactDir.eachFile {
                if (it.name.matches("(.*)\\.zip")) {
                    from zipTree(it)
                }
            }
            into artifactDir
        }
    }
}

task cleanArtifacts(type: Delete) {
    delete(artifactDir)
}

task resolveArtifacts(type: Copy) {
    group "dependancies"
    dependsOn cleanArtifacts
    from configurations.artifact.resolve().collect { zipTree(it) }
    into artifactDir
}

task cleanIdeTar(type: Delete) {
    delete(linuxIdeDir)
}

task extractIdeTar() {
    dependsOn "buildFlintIde"
    dependsOn cleanIdeTar
    doFirst {
        copy {
            from tarTree("$ideDir/Flint.tar.gz")
            into linuxIdeDir
        }
    }
}

task startFlintLinuxIde(type: Exec) {
    dependsOn(extractIdeTar)
    group "flintide"
    workingDir "$linuxIdeDir/bin"
    commandLine "./flint.sh"
}

task copyMbeddrPlugins(type: Copy) {
    dependsOn(resolveArtifacts)
    from "${artifactDir}/com.mbeddr.platform"
    into "${mpsDir}/plugins"
}


import org.dom4j.io.OutputFormat
import org.gradle.internal.os.OperatingSystem

task resolveMps(type: Copy) {
    from configurations.mps.resolve().collect { zipTree(it) }
    into mpsDir
    finalizedBy(copyMbeddrPlugins)
    finalizedBy("addFxLibs")
    finalizedBy("downloadJbr")
}

task cleanProject(type: Delete) {
    group "project"
    dependsOn(cleanResources)
    dependsOn(cleanArtifacts)
    dependsOn(cleanIdeTar)
    dependsOn(cleanLibs)
    dependsOn(cleanPlatformLibs)
    getTasksByName("clean", true).each {
        dependsOn(it)
    }
    delete(project("code").buildDir)
    delete(buildDir)
    delete("$projectDir/node_modules")
}

def currentPlatform() {
    if (OperatingSystem.current().isWindows()) {
        return platforms[2]
    }
    if (OperatingSystem.current().isMacOsX()) {
        return platforms[1]
    }
    return platforms[0]
}

task initProject() {
    group "project"
    dependsOn(resolveMps)
    dependsOn("installLocalGitHook")
    dependsOn(resolveLibs)
    dependsOn(resolveArtifacts)
    dependsOn(resolvePlatformLibs)
    dependsOn(fetchResources)
}

// Build Scripts
task generateScripts(type: de.itemis.mps.gradle.RunAntScript) {
    script = file("$codeDir/mainBuild.xml")
    targets = ["generate"]
    finalizedBy("fixClassPathIssues")
}

task buildFlint(type: de.itemis.mps.gradle.RunAntScript, dependsOn: generateScripts) {
    script = file("$codeDir/fixed-build-Flint.xml")
    targets = ["generate", "build"]
}

task buildFlintIde(type: de.itemis.mps.gradle.RunAntScript, dependsOn: [buildFlint, 'downloadAllJbrs']) {
    script = file("$codeDir/build-IdeDistribution.xml")
    targets = ["build"]
    finalizedBy("bundleMacosJbr")
}

task buildFlintPlugin(type: de.itemis.mps.gradle.RunAntScript, dependsOn: buildFlint) {
    script = file("$codeDir/build-PluginDistribution.xml")
    targets = ["build"]
}

task addFxLibs(type: Copy) {
    from configurations.mpsGenLib.resolve()
    into "${mpsDir}/lib"
}

task mpsTest(type: de.itemis.mps.gradle.RunAntScript, dependsOn: generateScripts) {
    script = file("$codeDir/fixed-build-Flint.xml")
    targets = ["generate", "test"]
    scriptArgs = ["-verbose"]
    test.finalizedBy("mpsTest")
    finalizedBy("htmlReport")
}

test.dependsOn("audit")

task collectXmlReports() {
    doLast {
        delete(reportsDir)
        copy {
            from {
                new File(project("code:java:FlintParser").buildDir, "test-results")
            }
            from {
                new File(project("code:java:FlintSources").buildDir, "test-results")
            }
            from {
                new File(codeDir, "$testFileName")
            }
            into "$reportsDir/sources"
        }
        delete(new File(codeDir, "$testFileName"))
    }
}

task htmlReport(type: de.itemis.mps.gradle.RunAntScript, dependsOn: collectXmlReports) {
    group "verification"
    script = file("$codeDir/html-report.xml")
}

def doesFillerFileExist(name) {
    def file = new File(flint_filler_executables_dir, name)
    return file.exists()
}

def downloadFillerFile(name) {
    def f = new File(flint_filler_executables_dir, name)
    f.getParentFile().mkdirs();
    if (f.exists()) {
        f.delete()
    }
    new URL("https://github.com/discipl/flintfiller/releases/download/${flint_filler_release_version}/${name}").withInputStream { i -> f.withOutputStream { it << i } }
    return f
}

task fetchFlintFillerLinux() {
    onlyIf { !doesFillerFileExist("flintfiller-linux") }
    doFirst {
        downloadFillerFile("flintfiller-linux")
    }
}

task fetchFlintFillerWindows() {
    onlyIf { !doesFillerFileExist("flintfiller-windows.exe") }
    doFirst {
        downloadFillerFile("flintfiller-windows.exe")
    }
}

task fetchFlintFillerMacos() {
    onlyIf { !doesFillerFileExist("flintfiller-macos") }
    doFirst {
        downloadFillerFile("flintfiller-macos")
    }
}

task fetchFlintFillerExecutables(dependsOn: [fetchFlintFillerLinux, fetchFlintFillerWindows, fetchFlintFillerMacos]) {
}


def getConfiguration(os) {
    def dependency = "com.jetbrains.jdk:jbr:$jbr_version:$os-x64@tgz"
    return configurations.detachedConfiguration(project.dependencies.create(dependency))
}

task downloadWindowsJbr(type: Copy) {
    group = 'jbr'
    def dirName = "windows"
    def downloadDir = new File(jbrsDir, dirName)
    onlyIf { !downloadDir.exists() || downloadDir.list().size() == 0 }
    doFirst {
        delete {
            delete downloadDir
        }
    }
    from(getConfiguration(dirName).resolve().collect { tarTree(it) })
    into(downloadDir)
}

task downloadLinuxJbr(type: Copy) {
    group = 'jbr'
    def dirName = "linux"
    def downloadDir = new File(jbrsDir, dirName)
    onlyIf { !downloadDir.exists() || downloadDir.list().size() == 0 }
    doFirst {
        delete {
            delete downloadDir
        }
    }
    from(getConfiguration(dirName).resolve().collect { tarTree(it) })
    into(downloadDir)
}

def shouldDownloadMacosJBR() {
    if(OperatingSystem.current().isWindows()){
        logger.warn('Cannot build MAC distribution on windows')
        return false
    }
    return true
}

task bundleMacosJbr() {
    group = 'jbr'
    def dirName = "osx"
    def downloadDir = new File(jbrsDir, dirName)
    onlyIf { shouldDownloadMacosJBR() }
    doFirst {
        delete {
            delete new File(ideDir, 'Flint.app')
        }
        exec {
            workingDir ideDir
            commandLine 'unzip', 'Flint.macos.zip'
        }
        def oldJbr = new File(ideDir, "Flint.app/Contents/jbr")
        delete {
            delete oldJbr
        }
        def jbr = new File(downloadDir, "jbr/Contents")
        oldJbr.mkdirs()
        exec {
            commandLine 'cp', '-r', jbr.absolutePath, new File(oldJbr, "Contents").absolutePath
        }
        delete {
            delete new File(ideDir, 'Flint_jbr.macos.zip')
            delete new File(ideDir, 'Flint.macos.zip')
        }
        exec {
            workingDir ideDir
            commandLine 'zip','-r', 'Flint.macos.zip', 'Flint.app'
        }
        delete {
            delete new File(ideDir, 'Flint.app')
        }
    }
}

task downloadMacOsJbr(type: Copy, group: 'jbr') {
    group = 'jbr'
    def dirName = "osx"
    def downloadDir = new File(jbrsDir, dirName)
    onlyIf { shouldDownloadMacosJBR() && (!downloadDir.exists() || downloadDir.list().size() == 0) }
    doFirst {
        delete {
            delete downloadDir
        }
    }
    def dependency = "net.adoptopenjdk:jdk:$osx_jdk_version:macosx-x64@tar.gz"
    def config = configurations.detachedConfiguration(project.dependencies.create(dependency))
    def file = config.resolve().collect { it }[0]
    from(file)
    into(downloadDir)
    doLast {
        exec {
            workingDir downloadDir
            commandLine 'tar', '-xf', file.name
        }
        def renameFile = new File(downloadDir, "jdk-" + osx_jdk_version.replace("-", "+"))
        renameFile.renameTo(downloadDir.path + "/jbr")
    }
}

task downloadAllJbrs(dependsOn: [downloadWindowsJbr, downloadLinuxJbr, downloadMacOsJbr]) {
    group = 'jbr'
}


def createClassPathJar(org.dom4j.Element project, org.dom4j.Element target, String simpleName) {
    org.dom4j.Element classPath = (org.dom4j.Element) target.selectSingleNode("javac/classpath")
    List<org.dom4j.Node> fileSets = classPath.selectNodes("fileset")

    if (fileSets.size < 10) {
        return
    }

    def jarTaskName = "build" + simpleName + "ClassPathJar"
    def pathId = "build.classpath" + simpleName
    def jarName = simpleName + "classpath.jar"
    def jarPath = "\${basedir}/build/" + jarName
    def propertyName = "lib.list" + simpleName

    target.addAttribute("depends", target.attributeValue("depends") + ", " + jarTaskName)
    org.dom4j.Element path = project.addElement("path").addAttribute("id", pathId)

    fileSets.each {
        it.detach()
        path.add(it)
    }

    project.addElement("manifestclasspath").addAttribute("property", propertyName).addAttribute("jarfile", jarPath).addElement("classpath").addAttribute("refid", pathId)
    classPath.addElement("fileset").addAttribute("file", jarPath)

    org.dom4j.Element jarTarget = project.addElement("target").addAttribute("name", jarTaskName)
    jarTarget.addElement("mkdir").addAttribute("dir", "\${basedir}/build")
    org.dom4j.Element jar = jarTarget.addElement("jar").addAttribute("jarfile", jarPath)
    jar.addElement("manifest").addElement("attribute").addAttribute("name", "Class-Path").addAttribute("value", ". \${" + propertyName + "}")
}

task fixClassPathIssues(dependsOn: ["generateScripts"]) {
    doFirst {
        file("$codeDir/build").mkdirs()
        def file = file("$codeDir/build-Flint.xml")
        org.dom4j.io.SAXReader reader = new org.dom4j.io.SAXReader()
        org.dom4j.Document document = reader.read(file)
        org.dom4j.Element project = (org.dom4j.Element) document.selectSingleNode("/project")

        project.selectNodes("target").each {
            if (it instanceof org.dom4j.Element) {
                org.dom4j.Element targetElement = ((org.dom4j.Element) it)
                def name = targetElement.attributeValue("name")
                if (name != null && name.startsWith("java.compile.")) {
                    name = name.replaceFirst("java.compile.", "").replaceAll("\\W+", "_").toLowerCase()
                    println name
                    createClassPathJar(project, targetElement, name)
                }
            }
        }

        project.selectNodes("target/generate/jvmargs/arg").each {
            if (it instanceof org.dom4j.Element) {
                org.dom4j.Element jvmElement = ((org.dom4j.Element) it)
                def value = jvmElement.attributeValue("value")
                if (value != null && value.startsWith("-Xmx")) {
                    value = "-Xmx1024m"
                    jvmElement.attribute("value").setValue(value)
                    println "Setting memory value to: " + value
                }
            }
        }

        org.dom4j.io.XMLWriter writer = new org.dom4j.io.XMLWriter(new FileWriter(new File("$codeDir/fixed-build-Flint.xml")), org.dom4j.io.OutputFormat.createPrettyPrint());
        writer.write(document);
        writer.close();
    }
}

plantUml {
    render input: "docs/diagrams/uml/*.puml", output: "${rootProject.rootDir.path}/docs/diagrams/uml/renders", format: 'png'
    render input: "docs/diagrams/sequence/*.puml", output: "${rootProject.rootDir.path}/docs/diagrams/sequence/renders", format: 'png'
}

task installLocalGitHook(type: Copy){
    from new File(rootProject.rootDir, 'scripts/pre-commit')
    into { new File(rootProject.rootDir, '.git/hooks')}
    fileMode 0775
}