build.gradle

plugins {
    id 'de.undercouch.download' version '5.6.0'
    id 'base'
    id 'maven-publish'
}

import de.undercouch.gradle.tasks.download.Download

import java.util.regex.Pattern

if (!project.hasProperty('mpsVersion')) {
    throw new GradleException("mpsVersion property must be defined, example: '2024.1.2' or '2024.2-EAP1'")
}

def mpsMajorRegex = Pattern.compile(/^(\d{4}\.\d)(?!\d)/) // four digits, '.', a digit, not immediately followed by a digit
def mpsMajorMatcher = mpsMajorRegex.matcher(project.mpsVersion)

if (!mpsMajorMatcher.find()) {
    throw new GradleException("mpsVersion property must begin with a version number, example: '2024.1.2' or '2024.2-EAP1'")
}

ext.mpsMajor = mpsMajorMatcher.group(1)

def mpsUnzipDir = layout.buildDirectory.dir("MPS-${mpsVersion}").get().asFile
def mpsDownloadFile = layout.buildDirectory.file("MPS-${mpsVersion}.zip")
def eapSuffix = (mpsVersion.contains("EAP")) ? " EAP" : ""
def mpsUnpackedDir = new File(mpsUnzipDir, "MPS ${mpsMajor}${eapSuffix}")

task testPackaging{
    description "Task triggering all packaging tasks"
}

testPackaging.dependsOn {
    tasks.withType(Jar).findAll {jarTask -> jarTask.name.startsWith('package')}
}

// Downloads MPS from jetbrains.com into ${mpsDownloadFile}
task downloadMPS(type: Download) {
    src "http://download.jetbrains.com/mps/${mpsMajor}/MPS-${mpsVersion}.zip"
    dest mpsDownloadFile
    overwrite false
}

task unzipMPS(type: Sync, dependsOn: downloadMPS) {
    from(zipTree(mpsDownloadFile))
    into(mpsUnzipDir)
}

task publishMPS(type: Zip, dependsOn: unzipMPS) {
    from mpsUnpackedDir
}

def additionalPomInfo = {
    licenses {
        // official SPDX identifier
        // see https://spdx.org/licenses/ for list
        license {
            name = "Apache-2.0"
            url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
            comments = "A business-friendly OSS license"
            distribution = "repo"
        }
    }
    organization {
        name = "JetBrains s.r.o"
        url = "https://www.jetbrains.com"
    }
}

publishing {
    repositories {
        maven {
            name = "itemisCloud"
            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")
            }
        }
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/mbeddr/build.publish.mps")
            if (project.hasProperty("gpr.token")) {
                credentials {
                    username = project.findProperty("gpr.user")
                    password = project.findProperty("gpr.token")
                }
            }
        }
    }
    publications {
        mps(MavenPublication) {
            groupId 'com.jetbrains'
            artifactId 'mps'
            version mpsVersion
            artifact publishMPS
            pom additionalPomInfo
        }
    }
}

/*
 * Repackage frequently needed JAR libraries shipping with MPS (in the lib and plugins folders) as individually consumable artifacts.
 * This is useful for the development of command line utilities, Maven plugins, Gradle plugins, or other things
 * that require only smaller parts of the MPS runtime and don't want to end up with a full MPS in their dependencies.
 */

class MpsJar {
    final String name
    String customArtifactId

    String relativePath

    String relativeSourcesPath
    final List<String> sourceIncludes = new ArrayList<>()

    MpsJar(String name) { this.name = name }

    void sourcesInclude(String pattern) {
        sourceIncludes.add(pattern)
    }
}

def mpsJars = objects.domainObjectContainer(MpsJar) { new MpsJar(it) }

static String baseName(String file) {
    if (file == null) {
        throw new IllegalArgumentException("file must not be null")
    }
    String name = new File(file).name
    int lastDot = name.lastIndexOf('.')
    if (lastDot == -1) {
        return name
    } else {
        return name.substring(0, lastDot)
    }
}

void createPublicationsFromMpsJars(Iterable<MpsJar> mpsJars, mpsUnpackedDir, additionalPomInfo) {
    mpsJars.each { mpsJar ->
        final jarBaseName = baseName(mpsJar.relativePath)

        def packageTask = tasks.register("package${mpsJar.name.capitalize()}", Jar) {
            dependsOn(unzipMPS)

            archiveBaseName = jarBaseName
            from zipTree("${mpsUnpackedDir}/${mpsJar.relativePath}")
        }

        TaskProvider<Jar> packageSourcesTask

        if (mpsJar.relativeSourcesPath == null) {
            if (!mpsJar.sourceIncludes.isEmpty()) {
                throw new IllegalArgumentException("MPS jar ${mpsJar.name} specified source include patterns but no source path")
            }
            packageSourcesTask = null
        } else {
            packageSourcesTask = tasks.register("package${mpsJar.name.capitalize()}Sources", Jar) {
                dependsOn(unzipMPS)
                archiveBaseName = jarBaseName
                archiveClassifier = 'sources'
                from(zipTree("$mpsUnpackedDir/${mpsJar.relativeSourcesPath ?: 'lib/MPS-src.zip'}")) { CopySpec spec ->
                    spec.include(mpsJar.sourceIncludes)
                }
            }
        }

        publishing.publications.create(mpsJar.name, MavenPublication) {
            groupId 'com.jetbrains'
            artifactId mpsJar.customArtifactId ?: jarBaseName
            version mpsVersion
            artifact packageTask
            if (packageSourcesTask != null) {
                artifact packageSourcesTask
            }
            pom additionalPomInfo
        }
    }
}

mpsJars.configure {
    annotations {
        relativePath = 'lib/annotations.jar'
    }

    mpsConsoleIdeCommandsRuntime {
        relativePath = 'plugins/mps-console/lang/jetbrains.mps.console.ideCommands.runtime.jar'
        relativeSourcesPath = 'plugins/mps-console/lang/jetbrains.mps.console.ideCommands.runtime-src.jar'

        customArtifactId = 'mps-console-ide-commands-runtime'
    }

    mpsCore {
        relativePath = 'lib/mps-core.jar'
        relativeSourcesPath = 'lib/MPS-src.zip'
    }

    mpsEditor {
        relativePath = 'lib/mps-editor.jar'
    }

    mpsEditorApi {
        relativePath = 'lib/mps-editor-api.jar'
    }

    mpsEditorRuntime {
        relativePath = 'lib/mps-editor-runtime.jar'
    }

    mpsEnvironment {
        relativePath = 'lib/mps-environment.jar'

        relativeSourcesPath = 'lib/MPS-src.zip'
        sourcesInclude 'jetbrains/mps/tool/common/**'
        sourcesInclude 'jetbrains/mps/tool/environment/**'
        sourcesInclude 'jetbrains/mps/core/tool/environment/**'
    }

    mpsHttpsupportRuntime {
        relativePath = 'plugins/mps-httpsupport/solutions/jetbrains.mps.ide.httpsupport.runtime.jar'

        relativeSourcesPath = 'lib/MPS-src.zip'
        sourcesInclude 'jetbrains/mps/ide/httpsupport/runtime/**'
    }

    if (mpsVersion < '2023') {
        // 2022.3 was the last version to have these jars
        mpsMessaging {
            relativePath = 'lib/mps-messaging.jar'

            relativeSourcesPath = 'lib/MPS-src.zip'
            sourcesInclude 'jetbrains/mps/messages/**'
        }
    }

    mpsModelchecker {
        relativePath = 'plugins/mps-modelchecker/lib/modelchecker.jar'

        relativeSourcesPath = 'lib/MPS-src.zip'
        sourcesInclude 'jetbrains/mps/ide/modelchecker/**'
    }

    mpsOpenApi {
        relativePath = 'lib/mps-openapi.jar'
        relativeSourcesPath = 'lib/MPS-src.zip'

        sourcesInclude 'org/jetbrains/mps/**'
    }

    mpsPlatform {
        relativePath = 'lib/mps-platform.jar'
        relativeSourcesPath = 'lib/MPS-src.zip'
    }

    mpsProjectCheck {
        relativePath = 'lib/mps-project-check.jar'

        relativeSourcesPath = 'lib/MPS-src.zip'
        sourcesInclude 'jetbrains/mps/checkers/**'
        sourcesInclude 'jetbrains/mps/core/platform/MPSProjectValidation.java'
        sourcesInclude 'jetbrains/mps/project/validation/**'
    }

    mpsRun {
        relativePath = 'lib/mpsant/mps-run.jar'

        // MPS-src.zip does not contain sources for mps-run.jar
        //relativeSourcesPath = 'lib/MPS-src.zip'
    }

    mpsTool {
        relativePath = 'lib/mpsant/mps-tool.jar'
        relativeSourcesPath = 'lib/MPS-src.zip'
        sourcesInclude 'jetbrains/mps/tool/builder/**'
    }

    mpsWorkbench {
        relativePath = 'lib/mps-workbench.jar'
    }

    util {
        relativePath = 'lib/util.jar'
        relativeSourcesPath = 'lib/MPS-src.zip'
    }
}

createPublicationsFromMpsJars(mpsJars, mpsUnpackedDir, additionalPomInfo)