build.gradle

buildscript {
    // (1) Year and Version -- (a) IC-2017.3, (b) 2017.2.4, (c) 2018.1
    // (2) Build ID -- (a) IU-163.7890, (b) 171.1234
    // (3) Named Snapshots -- (a) LATEST-EAP-SNAPSHOT, (b) LATEST-TRUNK-SNAPSHOT
    ext.since_from_version = { version ->
        // (1) Year and Version

        def since = version =~ /([A-Z]+-)?20([0-9][0-9])\.([1-3])(\.[0-9]+)?$/
        if (since.matches()) {
            return "${since.group(2)}${since.group(3)}"
        }

        // (2) Build ID

        since = version =~ /([A-Z]+-)?([0-9][0-9][0-9])\.[0-9]+?$/
        if (since.matches()) {
            return since.group(2)
        }

        // (3) Named Snapshots

        def repositoryPath = "https://www.jetbrains.com/intellij-repository/snapshots/com/jetbrains/intellij/idea/BUILD"
        def build = new File("$projectDir/build/BUILD-${version}.txt")
        if (!build.exists()) {
            build.parentFile.mkdirs()
            println "Downloading build version file '$repositoryPath/$version/BUILD-${version}.txt' to '${build.absolutePath}'"
            new URL("$repositoryPath/$version/BUILD-${version}.txt").withInputStream { input ->
                build.withOutputStream { output -> (output << input).close() }
            }
        }

        return build.readLines()[0].split('\\.')[0]
    }

    ext.idea_version = System.getenv("IDEA_VERSION") ?: '2024.2'
    ext.idea_since_build = ext.since_from_version(ext.idea_version).toInteger()
    ext.idea_type = System.getenv("IDEA_TYPE") ?: 'IC'

    if (ext.idea_since_build >= 242) {
        ext.kotlin_version = "1.9.25"
        ext.java_version = 21
    } else if (ext.idea_since_build >= 223) {
        ext.kotlin_version = "1.8.10"
        ext.java_version = 17
    } else {
        ext.kotlin_version = "1.7.21"
        ext.java_version = 11
    }
    ext.kotlin_stdlib = "kotlin-stdlib"

    ext.saxon_version = "9.9.1-7"
    ext.jsoup_version = "1.15.4"

    ext.junit5_version = "5.9.1"
    ext.junit_platform_version = "1.9.1"

    ext.plugin_version = '1.9.4'
    // Suffix ordering:
    //    `'-snapshot'` -- for development builds
    //    `'-eap-###'`  -- for early access preview builds (`-eap-1`, `-eap-2`, `-eap-3`, etc.)
    //    `''`          -- for release builds
    ext.suffix = ''

    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

plugins {
    id "org.jetbrains.intellij" version "1.17.3"
}

configure(allprojects - project(':src')) {
    apply plugin: 'org.jetbrains.intellij'
    apply plugin: 'idea'
    apply plugin: 'kotlin'
    apply plugin: 'jacoco'

    group 'uk.co.reecedunn.intellij.plugin.xquery'
    version = plugin_version + '-' + idea_since_build.toString() + suffix

    repositories {
        mavenCentral()
        mavenLocal()
    }

    kotlin {
        jvmToolchain(java_version)
    }

    intellij {
        version = idea_version
        type = idea_type
    }

    runIde {
        maxHeapSize = "2g"
    }

    dependencies {
        testImplementation "org.junit.jupiter:junit-jupiter-api:$junit5_version"

        testRuntimeOnly "org.junit.platform:junit-platform-launcher:$junit_platform_version"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junit5_version"
    }

    tasks {
        // Using the IntelliJ gradle plugin to provide the IntelliJ platform SDK in
        // each subproject results in various deployment related tasks being added
        // to those subprojects. As this plugin only uses those tasks on the main
        // project, those tasks are disabled globally and only enabled for the
        // main project.
        buildPlugin.enabled = false
        prepareSandbox.enabled = false
        prepareTestingSandbox.enabled = false
        publishPlugin.enabled = false
        runIde.enabled = false
        verifyPlugin.enabled = false
        buildSearchableOptions.enabled = false
    }

    test {
        useJUnitPlatform()

        // IntelliJ requires the tests to be run headless when loading icons, etc.
        systemProperty("java.awt.headless", "true")
    }
}

dependencies {
    implementation project(':src:kotlin-intellij')
    implementation project(':src:lang-core')
    implementation project(':src:plugin-api')

    implementation project(':src:plugin-basex')
    implementation project(':src:plugin-existdb')
    implementation project(':src:plugin-marklogic')
    implementation project(':src:plugin-saxon')
    implementation project(':src:plugin-xijp')

    implementation project(':src:lang-xdm')
    implementation project(':src:lang-xpm')

    implementation project(':src:lang-xpath')
    implementation project(':src:lang-xquery')
    implementation project(':src:lang-xslt')
    implementation project(':src:lang-xproc')

    implementation project(':src:lang-java')
    implementation project(':src:lang-xqdoc')

    implementation project(':src:plugin-expath')
    implementation project(':src:plugin-exquery')
    implementation project(':src:plugin-w3')

    testImplementation project(':src:intellij-test')
}

if (ext.idea_since_build >= 223) {
    intellij.plugins = [
        'com.intellij.properties',
        'org.intellij.intelliLang',
        'java'
    ]
} else {
    intellij.plugins = [
        'coverage',
        'com.intellij.properties',
        'org.intellij.intelliLang',
        'java'
    ]
}

if (idea_type == 'IU') {
    if (idea_since_build >= 193) {
        sourceSets.main.resources.srcDirs += 'src/main/resources-microservices/193'
    } else {
        sourceSets.main.resources.srcDirs += 'src/main/resources-microservices/compat'
    }
} else {
    sourceSets.main.resources.srcDirs += 'src/main/resources-microservices/compat'
}

tasks {
    // Using the IntelliJ gradle plugin to provide the IntelliJ platform SDK in
    // each subproject results in various deployment related tasks being added
    // to those subprojects. As this plugin only uses those tasks on the main
    // project, those tasks are disabled globally and only enabled for the
    // main project.
    buildPlugin.enabled = true
    prepareSandbox.enabled = true
    prepareTestingSandbox.enabled = true
    publishPlugin.enabled = true
    runIde.enabled = true
    verifyPlugin.enabled = true
    buildSearchableOptions.enabled = true
}

println "Building for IntelliJ ${idea_type} version '${idea_version}', since build '${idea_since_build}'"

intellij.updateSinceUntilBuild = true
intellij.sameSinceUntilBuild = true // 'until' is an open 'since' build

patchPluginXml {
    sinceBuild = "${idea_since_build}"
}

repositories {
    mavenCentral()
}