build.gradle

plugins {
    id 'de.itemis.mps.gradle.common' version '1.13.+'
    id "com.github.breadmoirai.github-release" version "2.4.1"
    id 'maven-publish'
    id 'base'
}

import de.itemis.mps.gradle.*

import java.time.LocalDateTime

apply plugin: 'download-jbr'

downloadJbr {
    jbrVersion = '17.0.8.1-b1000.32'
}

// detect if we are in a CI build
if (project.hasProperty("forceCI")) {
    ext.ciBuild = true
} else {
    //on teamcity we are in a CI build
    if (project.hasProperty("teamcity") && !project.hasProperty('mpsHomeDir')) {
        ext.ciBuild = true
    } else {
        ext.ciBuild = false
    }
}

// Default repository credentials
if (!project.hasProperty('nexusUsername')) {
    ext.nexusUsername = ''
    ext.nexusPassword = ''
}
logger.info 'Repository username: {}', project.nexusUsername

// Dependency versions

// major version, e.g. '2021.1', '2021.2'
ext.mpsMajor = '2023.2'
// optional minor/bugfix number (not added to the final build version)
ext.mpsMinor = ''
// e.g. Beta, EAP, RC
ext.mpsReleaseType = ''

def appendOpt = { str,pre -> !str.isEmpty() ? "${pre}${str}" : "" }
ext.mpsVersion =  "$mpsMajor" + appendOpt(mpsMinor, '.') + appendOpt(mpsReleaseType, '-')

if (ciBuild) {
    String branch = GitBasedVersioning.gitBranch

    def buildMajor = mpsMajor.split("\\.").first()
    def buildMinor = mpsMajor.split("\\.").last()
    def buildNumber = System.env.BUILD_NUMBER.toInteger()
    if (branch.matches(/(maintenance|mps)[\/-](mps)?\d+(\.\d+)*/)) {
        version = "$buildMajor.$buildMinor.$buildNumber.${GitBasedVersioning.gitShortCommitHash}"
    } else {
        version = GitBasedVersioning.getVersionWithCount(buildMajor, buildMinor, buildNumber)
    }

    println "##teamcity[buildNumber '${version}']"
} else {
    println "Local build detected, version will be SNAPSHOT"
    version = ext.mpsMajor + appendOpt(ext.mpsMinor , '.') + "-SNAPSHOT"
}

def userHome = System.properties['user.home']
def mpsPluginsDirPattern
if (System.properties['os.name'].toLowerCase().contains('mac')) {
    mpsPluginsDirPattern = "$userHome/Library/Application Support/%s"
} else {
    mpsPluginsDirPattern = "$userHome/.%s/config/plugins"
}

if (project.hasProperty("MPS_PATHS_SELECTOR")) {
    ext.mpsPluginsDir = sprintf(mpsPluginsDirPattern, project.getProperty("MPS_PATHS_SELECTOR"))
} else {
    ext.mpsPluginsDir = sprintf(mpsPluginsDirPattern, "MPS$mpsMajor")
}

ext.releaseRepository = 'https://artifacts.itemis.cloud/repository/maven-mps-releases/'
ext.snapshotRepository = 'https://artifacts.itemis.cloud/repository/maven-mps-snapshots/'
ext.publishingRepository = version.toString().endsWith("-SNAPSHOT") ? snapshotRepository : releaseRepository


configurations {
    mps
}

dependencies {
    mps "com.jetbrains:mps:$mpsVersion"
}

repositories {
    maven { url 'https://artifacts.itemis.cloud/repository/maven-mps/' }
}

ext.skipResolveMps = project.hasProperty('mpsHomeDir')
ext.mpsHomeDir = rootProject.file(project.findProperty('mpsHomeDir') ?: "$buildDir/mps")

if (project.skipResolveMps) {
    task resolveMps {
        doLast {
            logger.info "MPS resolution skipped"
            logger.info "MPS home: " + mpsHomeDir.getAbsolutePath()
        }
    }
} else {
    task resolveMps(type: Copy) {
        dependsOn configurations.mps
        from {
            configurations.mps.resolve().collect { zipTree(it) }
        }
        into mpsHomeDir
    }
}

// -------- Model API ----------------------

configurations {
    modelApi
}

dependencies {
    def modelixCoreVersion = "2.1.9"
    modelApi("org.modelix:model-api:$modelixCoreVersion")
}

task copyModelApi() {
    dependsOn configurations.modelApi
    doLast {
        // copy transitive dependencies without version in the file name
        // otherwise each new version would require a change of the MPS solution
        def libFolder = file("$projectDir/code/model-api/org.modelix.model.api/lib")
        libFolder.deleteDir()
        libFolder.mkdir()
        def versionsFile = file("$libFolder/versions.txt")
        for (final def artifact in configurations.modelApi.resolvedConfiguration.resolvedArtifacts) {
            // these libs are part of MPS
            if (
                    artifact.moduleVersion.id.name.startsWith("log4j")
                    || artifact.moduleVersion.id.name.startsWith("annotations")
                    || artifact.moduleVersion.id.name.startsWith("slf4j-api")

            ) {
                versionsFile.append("already part of mps: " + artifact.file.name + "\n")
                continue
            }

            def sourceFile = java.nio.file.Path.of(artifact.file.absolutePath)
            def targetFile = java.nio.file.Path.of(libFolder.absolutePath).resolve(artifact.moduleVersion.id.name + "." + artifact.extension)
            java.nio.file.Files.copy(sourceFile, targetFile)
            versionsFile.append(artifact.file.name + "\n")
        }
    }
}

// -----------------------------------------


configurations {
    ant_lib
    diagram_lib
}

dependencies {
    ant_lib "org.apache.ant:ant-junit:1.10.9"

    def elkVersion = "0.9.0"
    diagram_lib ("org.eclipse.elk:org.eclipse.elk.alg.common:$elkVersion") {
        transitive = false
    }
    diagram_lib ("org.eclipse.elk:org.eclipse.elk.alg.layered:$elkVersion") {
        transitive = false
    }
    diagram_lib ("org.eclipse.elk:org.eclipse.elk.alg.mrtree:$elkVersion") {
        transitive = false
    }
    diagram_lib ("org.eclipse.elk:org.eclipse.elk.core:$elkVersion") {
        transitive = false
    }
    diagram_lib ("org.eclipse.elk:org.eclipse.elk.graph:$elkVersion") {
        transitive = false
    }
    diagram_lib ("org.eclipse.emf:org.eclipse.emf.common:2.29.0") {
        transitive = false
    }
    diagram_lib ("org.eclipse.emf:org.eclipse.emf.ecore:2.35.0") {
        transitive = false
    }
    diagram_lib ("org.eclipse.emf:org.eclipse.emf.ecore.xmi:2.36.0") {
        transitive = false
    }
}

configurations.diagram_lib.attributes.attribute(Attribute.of('org.gradle.jvm.environment', String), 'standard-jvm')

ext.buildScriptClasspath = project.configurations.ant_lib.fileCollection({
    true
})

def artifactsDir = new File(rootDir, 'artifacts')


ext.mps_home = '-Dmps.home=' + mpsHomeDir.getAbsolutePath()
ext.build_dir = '-Dbuild.dir=' + file(rootProject.projectDir.absolutePath).getAbsolutePath()
ext.artifacts_dir = '-Dartifacts.root=' + artifactsDir
ext.pluginVersion = "-DversionNumber=" + version
ext.buildDate = "-DbuildDate=" + new Date().toString()
ext.extensions_home = '-Dextensions.home=' + rootDir

// ___________________ utilities ___________________
File scriptFile(String relativePath) {
    new File("$rootDir/build/patched/$relativePath")
}

def defaultScriptArgs = [mps_home, build_dir, artifacts_dir, ext.buildDate, ext.pluginVersion]

afterEvaluate {
    project.ext["itemis.mps.gradle.ant.defaultJavaExecutable"] = tasks.getByName('downloadJbr').javaExecutable
    def jdk_home = null
    if (ext.has('java17_home')) {
        jdk_home = ext.get('java17_home')
    } else if (System.getenv('JB_JAVA17_HOME') != null) {
        jdk_home = System.getenv('JB_JAVA17_HOME')
    }
    if(jdk_home != null) {
        if (!new File(jdk_home, "lib").exists()) {
            throw new GradleException("Unable to locate JDK home folder. Detected folder is: $jdk_home")
        } else {
        ext["itemis.mps.gradle.ant.defaultJavaExecutable"] = new File(jdk_home, 'bin/java')
        }
    }
}

// enables https://github.com/mbeddr/mps-gradle-plugin#providing-global-defaults
ext["itemis.mps.gradle.ant.defaultScriptArgs"] = defaultScriptArgs
ext["itemis.mps.gradle.ant.defaultScriptClasspath"] = buildScriptClasspath

task resolved_diagram_dependencies(type: Copy) {
    from configurations.diagram_lib
    into file('code/diagram/solutions/de.itemis.mps.editor.diagram.runtime/lib')

    // Strip version numbers from file names
    rename { filename ->
        def ra = configurations.diagram_lib.resolvedConfiguration.resolvedArtifacts.find { ResolvedArtifact ra -> ra.file.name == filename }
        String finalName
        if (ra.classifier != null) {
            finalName = "${ra.name}-${ra.classifier}.${ra.extension}"
        } else {
            finalName = "${ra.name}.${ra.extension}"
        }
        return finalName
    }
}

def build_allScripts_unpatched = tasks.register('build_allScripts_unpatched', BuildLanguages) {
    dependsOn 'downloadJbr', resolveMps, copyModelApi, resolved_diagram_dependencies
    script "$rootDir/scripts/build.xml"
}

// Patch JNA path in generated build scripts until https://github.com/JetBrains/MPS/pull/71 is fixed
def patch_allScripts = tasks.register('patch_allScripts', Copy) {
    dependsOn build_allScripts_unpatched
    from 'build/generated'
    into 'build/patched'

    def isAarch64 = System.getProperty('os.arch') == 'aarch64'
    def jnaArch = isAarch64 ? 'aarch64' : 'amd64'

    filter {
        it.replace('"-Djna.boot.library.path=${artifacts.mps}/lib/jna"',
                   '"-Djna.boot.library.path=${artifacts.mps}/lib/jna/' + jnaArch + '"')
    }
}

task build_allScripts {
    dependsOn patch_allScripts
}

task build_languages(type: BuildLanguages, dependsOn: [build_allScripts]) {
    script scriptFile('languages/build.xml')
}

task run_tests(type: TestLanguages, dependsOn: build_languages) {
    description "Will execute all tests from command line"
    script scriptFile('tests/build.xml')
}

task install_nativelibs(type: Copy, dependsOn: build_languages) {
    from "$rootDir/artifacts/de.itemis.mps.extensions/"
    include "de.itemis.mps.nativelibs.loader/"
    into "$mpsPluginsDir"
}


task install(dependsOn: install_nativelibs) {
    description "Install the required plugins into the MPS plugin repository"
    group "Build Setup"
    doFirst {
        // check parent gradle file for definition of the variables
        println "Installing required mbeddr plugins to '$mpsPluginsDir'"
        if (!project.hasProperty("MPS_PATHS_SELECTOR")) {
            println "To change 'MPS<>' part, pass MPS_PATHS_SELECTOR property to gradle with -PMPS_PATHS_SELECTOR=<custom path selector>"
            println "The path selector only contains the the actual selector for instance \"MPS2017.3\" not the full qualifies path to the user plugin directory."
        }
    }
}

//

// Ant <junit> task support
repositories {
    mavenCentral()
}
configurations {
    junitAnt
}
dependencies {
    junitAnt 'junit:junit:4.12'
    junitAnt('org.apache.ant:ant-junit:1.10.9') {
        transitive = false
    }
    junitAnt('org.apache.ant:ant-junit4:1.10.9') {
        transitive = false
    }
}

task packageAllScripts(type: Zip, dependsOn: run_tests) {
    archiveBaseName = 'de.itemis.mps.extensions.allScripts'
    from artifactsDir
    include 'de.itemis.mps.extensions.allScripts/**'
}

task packageExtensions(type: Zip, dependsOn: run_tests) {
    archiveBaseName = 'de.itemis.mps.extensions'
    from artifactsDir
    include 'de.itemis.mps.extensions/**'
}

task cleanMps(type: Delete) {
    delete fileTree(dir: projectDir, include: ["**/classes_gen/**", "**/source_gen/**", "**/source_gen.caches/**", "tmp/**", "artifacts/**"])
}

clean.dependsOn cleanMps
assemble.dependsOn packageExtensions

allprojects {
    apply plugin: 'maven-publish'
    publishing {
        repositories {
            if (rootProject.hasProperty("artifacts.itemis.cloud.user") && rootProject.hasProperty("artifacts.itemis.cloud.pw")) {
                maven {
                    name = "itemisCloud"
                    url = project.publishingRepository
                    credentials {
                        username = rootProject.findProperty("artifacts.itemis.cloud.user")
                        password = rootProject.findProperty("artifacts.itemis.cloud.pw")
                    }
                }
            }
            if (rootProject.hasProperty("gpr.token")) {
                maven {
                    name = "GitHubPackages"
                    url = "https://maven.pkg.github.com/JetBrains/MPS-extensions"
                    credentials {
                        username = rootProject.findProperty("gpr.user")
                        password = rootProject.findProperty("gpr.token")
                    }
                }
            }
        }
    }
}

publishing {
    publications {
        extensions(MavenPublication) {
            groupId 'de.itemis.mps'
            artifactId 'extensions'
            artifact packageExtensions
            //Pom.withProvidedDep pom, configurations.mps
            pom.withXml {
                def dependenciesNode = asNode().appendNode('dependencies')
                configurations.mps.resolvedConfiguration.firstLevelModuleDependencies.each {
                    def dependencyNode = dependenciesNode.appendNode('dependency')
                    dependencyNode.appendNode('groupId', it.moduleGroup)
                    dependencyNode.appendNode('artifactId', it.moduleName)
                    dependencyNode.appendNode('version', it.moduleVersion)
                    dependencyNode.appendNode('type', it.moduleArtifacts[0].type)
                    dependencyNode.appendNode('scope', 'provided')
                }
            }
        }
    }
}

task pipInstall(type: Exec) {
    inputs.file("requirements.txt")
    commandLine "python3", "-m", "pip", "install", "-r", "requirements.txt"
}

task previewDocs(type: Exec, dependsOn: pipInstall) {
    commandLine "mkdocs", "serve"
}

task deployDocs(type: Exec, dependsOn: pipInstall) {
    commandLine "mkdocs", "gh-deploy", "--clean", "-r", "gh-pages", "--force"
}

defaultTasks 'build_languages'
task test(dependsOn: run_tests)

build_languages.mustRunAfter clean

task rebuild(dependsOn:[clean, build_languages])

def releaseNotes
def releaseName
def releaseTagName

if (rootProject.hasProperty("nightly_build")) {
    releaseName = 'Nightly Build ' + version
    releaseTagName = 'nightly-' + version
    releaseNotes = """Automated Nightly build from ${LocalDateTime.now() as String}."""
} else {
    releaseNotes = rootProject.findProperty("releaseNotes")
    releaseTagName = 'release-' + version
    releaseName = version
}


githubRelease {
    owner = 'jetbrains'
    repo = 'MPS-extensions'
    token = rootProject.findProperty("github.token") ?: "empty"
    tagName = releaseTagName
    targetCommitish = GitBasedVersioning.getGitCommitHash()
    body = releaseNotes
    prerelease = rootProject.hasProperty("nightly_build")
    releaseAssets = packageExtensions.outputs.files.files.collect {it.path}
    dryRun = false
}

tasks.named('githubRelease').configure {
    dependsOn packageExtensions
}