build.gradle

import de.itemis.mps.gradle.*
import de.itemis.mps.gradle.downloadJBR.*
import de.itemis.mps.gradle.tasks.*

plugins {
    id 'de.itemis.mps.gradle.common' version '1.29.1.+'
    id 'download-jbr' version '1.29.1.+'
    id 'base'
    id 'maven-publish'
    id 'co.riiid.gradle' version '0.4.2'

    id 'de.itemis.mps.gradle.launcher' version '2.5.2.+'

    id 'org.cyclonedx.bom' version '2.2.0'
}

ext.jbrVers = '21.0.5-b631.8'

downloadJbr {
    jbrVersion = jbrVers
}

// detect if we are in a CI build
if (System.env.CI != null && System.env.CI.toBoolean()) {
    // is this github
    ext.ciBuild = true
} else {
    // on teamcity we are in a CI build
    ext.ciBuild = project.hasProperty("teamcity")
}

// Project versions
ext.major = '999'
ext.minor = '9'

if (ciBuild) {
    String branch = GitBasedVersioning.gitBranch
    def buildNumber = System.env.GITHUB_RUN_NUMBER != null ? System.env.GITHUB_RUN_NUMBER.toInteger() : System.env.BUILD_NUMBER.toInteger()
    if (branch.startsWith("maintenance") || branch.startsWith("mps")) {
        version = "$major.$minor.$buildNumber.${GitBasedVersioning.gitShortCommitHash}"
    } else {
        version = GitBasedVersioning.getVersionWithCount(major, minor, buildNumber)
    }

    println "##teamcity[buildNumber '${version}']"
} else {
    println "Local build detected, version will be SNAPSHOT"
    version = "$major.$minor-SNAPSHOT"
}

group = 'org.mpsqa'

configurations {
    mps
    // includes also junit tasks support
    antLib

    plantuml { transitive = false }
    baseLib { transitive = false }
    treemap { transitive = false }
    jacoco { transitive = false }
}

dependencies {
    // Use the following dependency for published releases:
    //   mps 'com.jetbrains:mps:2024.3'
    mps 'com.jetbrains.mps:mps-prerelease:243.21565.10057'
    antLib "org.apache.ant:ant-junit:1.10.15"
    antLib "org.jacoco:org.jacoco.ant:0.8.13"

    plantuml "net.sourceforge.plantuml:plantuml-asl:1.2025.2"

    baseLib "org.apache.commons:commons-lang3:3.17.0"
    baseLib "commons-cli:commons-cli:1.5.0"
    baseLib "commons-io:commons-io:2.18.0"

    treemap "net.sf.jtreemap:jtreemap:1.1.3"
    treemap "net.sf.jtreemap:ktreemap:1.1.0-atlassian-01"

    def asmVersion = "9.2"
    def jacocoVersion = "0.8.13"

    jacoco "org.ow2.asm:asm:$asmVersion"
    jacoco "org.ow2.asm:asm-commons:$asmVersion"
    jacoco "org.ow2.asm:asm-tree:$asmVersion"
    jacoco "org.jacoco:org.jacoco.agent:$jacocoVersion"
    jacoco "org.jacoco:org.jacoco.ant:$jacocoVersion"
    jacoco "org.jacoco:org.jacoco.core:$jacocoVersion"
    jacoco "org.jacoco:org.jacoco.report:$jacocoVersion"
}

repositories {
    maven {
        url 'https://maven.pkg.github.com/mbeddr/*'
        credentials {
            username = project.findProperty("github_username") ?: System.getenv("GITHUB_ACTOR")
            password = project.findProperty("github_token") ?: System.getenv("GITHUB_TOKEN")
        }
    }
    maven {
        url 'https://artifacts.itemis.cloud/repository/maven-mps/'
    }
    maven {
        url 'https://packages.atlassian.com/maven-public/'
    }
    mavenCentral()
}

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: Sync) {
        dependsOn configurations.mps
        from {
            configurations.mps.resolve().collect { zipTree(it) }
        }
        into mpsHomeDir
    }
}

// tools needed for compiler support in ant calls
ext.buildScriptClasspath = project.configurations.antLib

def artifactsDir = file("$buildDir/artifacts")
def reportsDir = file("$buildDir/reports")
def dependenciesDir = file("$buildDir/dependencies")


// ___________________ utilities ___________________

def defaultScriptArgs = [
        'mps.home'                          : mpsHomeDir,
        'mps_home'                          : mpsHomeDir,
        'build.jna.library.path'            : new File(mpsHomeDir, "lib/jna/${System.getProperty('os.arch')}"),
        'mpsqa.home'                        : rootDir,
        'build.dir'                         : buildDir,
        'version'                           : version,
        'build.date'                        : new Date(),
]

// enables https://github.com/mbeddr/mps-gradle-plugin#providing-global-defaults
task configureJava {
    dependsOn "downloadJbr"
    doLast {
        project.ext["itemis.mps.gradle.ant.defaultScriptArgs"] = defaultScriptArgs.collect { "-D$it.key=$it.value".toString() }
        project.ext["itemis.mps.gradle.ant.defaultScriptClasspath"] = buildScriptClasspath
        project.ext["itemis.mps.gradle.ant.defaultJavaExecutable"] = tasks.getByName("downloadJbr").javaExecutable
        println project.findProperty("itemis.mps.gradle.ant.defaultJavaExecutable")
    }
}

// All MPS tasks depend on configureJava and resolveMps
tasks.withType(RunAntScript).configureEach {
    dependsOn(configureJava, resolveMps)
}

File scriptFile(String name) {
    file("$buildDir/scripts/$name")
}

def createResolveTask(taskName, configurationName, outputDir) {
    tasks.register(taskName, Sync) {
        from configurations."${configurationName}"
        into file(outputDir)
        // Strip version numbers from file names
        rename { filename ->
            def ra = configurations."${configurationName}".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
        }
    }
}

// Define tasks using the reusable function
createResolveTask('resolvePlantUML', 'plantuml', 'code/languages/org.mpsqa.arch/solutions/org.mpsqa.arch.pluginSolution/lib')
createResolveTask('resolveBaseLibs', 'baseLib', 'code/languages/org.mpsqa.base/solutions/org.mpsqa.base.lib/lib')
createResolveTask('resolveTreeMap', 'treemap', 'code/languages/org.mpsqa.base/solutions/org.mpsqa.treemap.lib/lib')
createResolveTask('resolveJacoco', 'jacoco', 'code/languages/org.mpsqa.testing/solutions/org.mpsqa.testcov.jacoco.rt/lib/lib')

task resolveDependencies(dependsOn: [resolvePlantUML, resolveBaseLibs, resolveTreeMap, resolveJacoco])


def build_allScripts = tasks.register('build_allScripts', BuildLanguages) {
    dependsOn resolveDependencies
    script scriptFile('build_all_scripts.xml')
}

// All other MPS tasks depend on build_allScripts
tasks.withType(RunAntScript).configureEach {
    if (it.name != build_allScripts.name) {
        it.dependsOn(build_allScripts)
    }
}

task build_base_languages(type: BuildLanguages) {
    script scriptFile('build-base-languages.xml')
}

task build_testing_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile('build-testing-languages.xml')
}

task test_testing(type: TestLanguages, dependsOn: [build_testing_languages]) {
    // MPS build language generator is confused about the basedir of the generated script so we set it manually
    scriptArgs = ["-Dbasedir=${file('code/languages/org.mpsqa.testing')}"]
    script scriptFile("test-testing.xml")
}

task build_clones_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-clones-languages.xml")
}

task build_mutant_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-mutant-languages.xml")
}

task build_unused_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-unused-languages-analysis.xml")
}

task build_arch_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-arch-analysis-languages.xml")
}

task build_deprecation_analysis_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-deprecated-analysis-languages.xml")
}

task build_lint_analysis_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-lint-analysis-languages.xml")
}

task build_profile_languages(type: BuildLanguages, dependsOn: [build_base_languages]) {
    script scriptFile("build-profile-languages.xml")
}

task build_sandboxes(type: BuildLanguages) {
    dependsOn 'build_base_languages'
    dependsOn 'build_unused_languages'
    dependsOn 'build_unused_languages'
    dependsOn ':testing:sandbox:assemble'

    script "$buildDir/scripts/build-sandboxes.xml"
}

tasks.register('build_main_languages') {
    dependsOn 'build_base_languages'
    dependsOn 'build_testing_languages'
    dependsOn 'build_clones_languages'
    dependsOn 'build_mutant_languages'
    dependsOn 'build_unused_languages'
    dependsOn 'build_arch_languages'
    dependsOn 'build_deprecation_analysis_languages'
    dependsOn 'build_lint_analysis_languages'
	dependsOn 'build_profile_languages'
}

tasks.register('build_all_languages') {
    dependsOn 'build_main_languages'

    dependsOn 'build_sandboxes'
}

task build_allInOne_package(type: BuildLanguages, dependsOn: [build_allScripts]) {
    dependsOn 'build_main_languages'
    script scriptFile("build-allInOne-package.xml")
}

task package_mpsqa(type: Zip, dependsOn: [build_allInOne_package, cyclonedxBom]) {
    archiveBaseName = 'org.mpsqa'
    from(artifactsDir) {
        include 'org.mpsqa.allInOne/**'
    }
    from(reportsDir) {
        include 'sbom.json'
        into 'org.mpsqa.allInOne'
    }
}

task test_clones(type: TestLanguages, dependsOn: build_clones_languages) {
    description "Will execute clones tests from command line"
	script scriptFile("test-clones.xml")
}

task test_lint(type: TestLanguages, dependsOn: build_lint_analysis_languages) {
    description "Will execute lint tests from command line"
    script scriptFile("build-lint-tests.xml")
}

tasks.register('check_lint', MpsCheck) {
    dependsOn(resolveMps)

    dependsOn(build_lint_analysis_languages)
    projectLocation = file('code/languages/org.mpsqa.lint')
    mpsHome = mpsHomeDir

    folderMacros.put('mpsqa.home', rootProject.layout.projectDirectory)

    pluginRoots.add(layout.dir(provider { new File(mpsHomeDir, 'plugins/mps-console') }))
    pluginRoots.add(layout.dir(provider { new File(mpsHomeDir, 'plugins/mps-modelchecker') }))
}

cyclonedxBom {
    destination = reportsDir
    outputName = "sbom"
    outputFormat = "json"
    includeLicenseText = false
    includeConfigs = ["plantuml","baseLib","treemap","jacoco"]
}

check.dependsOn(tasks.withType(TestLanguages))

assemble.dependsOn(tasks.withType(BuildLanguages))

publishing {
    repositories {
		maven {
			name = "GitHubPackages"
			url = uri("https://maven.pkg.github.com/mbeddr/mps-qa")
            credentials {
                username = project.findProperty("github_username") ?: System.getenv("GITHUB_ACTOR")
                password = project.findProperty("github_token") ?: System.getenv("GITHUB_TOKEN")
            }
		}
        if (project.hasProperty("artifacts.itemis.cloud.user") && project.hasProperty("artifacts.itemis.cloud.pw")) {
            maven {
                name = "ItemisNexus"
                url =  uri("https://artifacts.itemis.cloud/repository/maven-mps-releases")
                    credentials {
                        username = project.findProperty("artifacts.itemis.cloud.user")
                        password = project.findProperty("artifacts.itemis.cloud.pw")
                    }
            }
        }
    }
    publications {
        MPSQA(MavenPublication) {
            groupId 'org.mpsqa'
            artifactId 'all-in-one'
            artifact package_mpsqa
            pom.withXml {
                def dependenciesNode = asNode().appendNode('dependencies')
                def languageLibs = ['plantuml', 'baseLib', 'treemap', 'jacoco']
                languageLibs.each { configName ->
                    def configuration = configurations.findByName(configName)

                    configuration.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')
                    }
                }

                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 cleanMps(type: Delete) {
    delete fileTree(dir: projectDir, include: ["**/classes_gen/**", "**/source_gen/**", "**/source_gen.caches/**", "tmp/**"])
}

clean.dependsOn cleanMps

defaultTasks 'build'

task rebuild(dependsOn:[clean, build_allInOne_package])

ext.allProjectDirectoriesInDependencyOrder = [
        'org.mpsqa.base',
        'org.mpsqa.testing',
        'org.mpsqa.build',

        'org.mpsqa.arch',
        'org.mpsqa.clones',
        'org.mpsqa.deprecated',
        'org.mpsqa.lint',
        'org.mpsqa.mutant',
        'org.mpsqa.profile',
        'org.mpsqa.testing',
        'org.mpsqa.unused'
].collect { file("code/languages/$it") }
ext.mpsPluginRoots = ['mps-build', 'mps-console', 'mps-trove', 'mps-modelchecker', 'mps-tooltips', 'mps-testing']
        .collect { new File(mpsHomeDir, "plugins/$it") }
ext.jbrJavaLauncher = tasks.named('downloadJbr', DownloadJbrForPlatform).flatMap { it.javaLauncher }

tasks.register('migrate', MpsMigrate) {
    dependsOn(resolveMps, 'downloadJbr', 'build_all_languages')

    javaLauncher = jbrJavaLauncher
    mpsHome = mpsHomeDir
    folderMacros.put('mpsqa.home', layout.projectDirectory)
    projectDirectories.from(allProjectDirectoriesInDependencyOrder)
    pluginRoots.from(mpsPluginRoots)

    haltOnPrecheckFailure = true
    haltOnDependencyError = true
}

tasks.register('remigrate', Remigrate) {
    dependsOn(resolveMps, 'downloadJbr')
    mustRunAfter('migrate')

    // Technically we don't need to _depend_ on build_all_languages because we can opt to rerun only migrations that
    // come from MPS.
    mustRunAfter('build_all_languages')

    javaLauncher = jbrJavaLauncher
    mpsHome = mpsHomeDir
    folderMacros.put('mpsqa.home', layout.projectDirectory)
    projectDirectories.from(allProjectDirectoriesInDependencyOrder)
    pluginRoots.from(mpsPluginRoots)
}