build.gradle

//import org.jetbrains.changelog.ExtensionsKt


import org.jetbrains.changelog.Changelog
import org.jetbrains.changelog.exceptions.MissingVersionException
import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
import org.jetbrains.intellij.platform.gradle.TestFrameworkType
import org.jetbrains.intellij.platform.gradle.tasks.VerifyPluginTask

//import org.jetbrains.changelog.markdownToHTML

plugins {
    id 'java'
    id 'org.jetbrains.intellij.platform' version '2.10.5'
    id("org.jetbrains.kotlin.jvm") version "2.2.21"
    id 'org.jetbrains.changelog' version '2.5.0'
    id 'org.jetbrains.qodana' version '2025.2.2'
    id 'org.jetbrains.kotlinx.kover' version '0.9.3'
    id "io.freefair.lombok" version "9.1.0"
    id 'idea'
    id "org.sonarqube" version '7.2.0.6526'
    id 'jacoco'
}
def readPropertyString = (key) -> property(key).toString()
def readPropertyStringUnsetEmpty = (key) ->  {
    def value = readPropertyString(key)
    return value == "" ? null : value
}
def verifyFailureLevel = EnumSet.copyOf(VerifyPluginTask.FailureLevel.ALL)
verifyFailureLevel.remove(VerifyPluginTask.FailureLevel.NOT_DYNAMIC)
def channel = getChannel(readPropertyString('pluginVersion'))

group readPropertyString('pluginGroup')
version "${readPropertyString('pluginVersion')}-${readPropertyString('pluginSincePlatformVersion')}"
apply plugin: 'org.jetbrains.intellij.platform'
apply plugin: 'org.jetbrains.changelog'
apply plugin: 'java'
apply plugin: 'idea'
apply plugin: "io.freefair.lombok"

intellijPlatform {
    pluginConfiguration {
        name.set(readPropertyString('pluginName'))
        version.set(project.version)

        description.set(file('includes/pluginDescription.html').text)
        //changeNotes.set(provider { changelog.getLatest().toHTML() })
        def allChanges = { changelog.getAll().values()
                .collect { it.withHeader(true) }
                .collect { it.withLinks(false) }
                .collect { it.withLinkedHeader(false) }
                .collect { it.withSummary(true) }
                .collect { changelog.renderItem(it as Changelog.Item, Changelog.OutputType.HTML)}
                .join('<br>\n')
        }
        def getChangelogForCurrentBuild = {
            def currentChangelog = changelog.getOrNull(readPropertyString("pluginVersion"))
            if (!currentChangelog) {
                try {
                    currentChangelog = changelog.getUnreleased()
                } catch (MissingVersionException missingVersionException) {
                    currentChangelog = changelog.getLatest()
                }
            }
            return currentChangelog
        }
        def lastChanges = {
            def item = getChangelogForCurrentBuild()
                    .withHeader(true)
                    .withLinks(false)
                    .withLinkedHeader(false)
                    .withSummary(true)
            changelog.renderItem(item, Changelog.OutputType.HTML)
        }
        //changeNotes.set(provider { allChanges() } )
        changeNotes.set(provider { lastChanges() } )

        ideaVersion {
            sinceBuild.set(readPropertyString("pluginSinceBuild"))
            untilBuild.set(readPropertyStringUnsetEmpty("pluginUntilBuild"))
            //untilBuild = provider { null }
        }
    }
    publishing {
        token.set(System.getenv("PUBLISH_TOKEN"))
        // pluginVersion is based on the SemVer (https://semver.org) and supports pre-release labels, like 2.1.7-alpha.3
        // Specify pre-release label to publish the plugin in a custom Release Channel automatically. Read more:
        // https://plugins.jetbrains.com/docs/intellij/deployment.html#specifying-a-release-channel
        channels.set([channel])
    }
    signing {
        def _privateKey = file('private/mcmics.pem')
        def _certificateChain = file('private/mcmics-sign.crt')
        privateKey.set(_privateKey.exists() ?  _privateKey.text : System.getenv("PRIVATE_KEY"))
        certificateChain.set(_certificateChain.exists() ?  _certificateChain.text : System.getenv("CERTIFICATE_CHAIN"))
        password.set(System.getenv("PRIVATE_KEY_PASSWORD"))
    }
    pluginVerification {
        // filled by task printProductsReleases
        // ideVersions = ["IU-${ideaVersionToVerify}"]
        // ideVersions = ["IC-2020.3", "PS-2020.3", "IU-2020.3"]
        failureLevel = verifyFailureLevel
        freeArgs = ['-mute', 'TemplateWordInPluginName']

        ides {
            recommended()
            ide IntelliJPlatformType.IntellijIdeaCommunity, "${platformVersionToVerify}"
//            select {
//                it.types = [IntelliJPlatformType.CLion]
//                it.channels = [ProductRelease.Channel.RELEASE]
//                it.sinceBuild = "${pluginSinceBuild}"
//                it.untilBuild = "${pluginUntilBuild}"
//            }
        }
    }
}

changelog {
    version = readPropertyString('pluginVersion')
    path = "${project.projectDir}/CHANGELOG.md"
    header = provider { "[${version.get()}]" }
    //headerParserRegex = ~/\d+\.\d+/
    itemPrefix = "-"
    keepUnreleasedSection = true
    combinePreReleases = true
    lineSeparator = "\n"
    repositoryUrl = readPropertyString('pluginRepositoryUrl')
    unreleasedTerm = "Unreleased"
    //groups = ["Added", "Changed", "Deprecated", "Removed"]
    groups = []
}

qodana {
    cachePath = file(".qodana").canonicalPath
}

// Configure Gradle Kover Plugin - read more: https://github.com/Kotlin/kotlinx-kover#configuration
kover {
    reports {
        total {
            xml {
                onCheck = true
            }
        }
    }
}

lombok {
    version = "1.18.38"
    disableConfig = false
}

idea {
    module {
        downloadJavadoc = true
        downloadSources = true
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(readPropertyString("javaVersion"))
    }
}

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    options.release.set(Integer.parseInt(readPropertyString("javaVersionTarget")))
}
tasks.wrapper {
    gradleVersion = readPropertyString("gradleVersion")
}

configurations {
    provided
    mockitoAgent
}

sourceSets {
    main {
        java {
            compileClasspath += configurations.provided
            runtimeClasspath += configurations.provided
        }
        resources {
        }
    }
    test {
        java {
            compileClasspath += configurations.provided
            runtimeClasspath += configurations.provided
        }
        resources {
        }
    }
}

repositories {
    mavenCentral()

    // IntelliJ Platform Gradle Plugin Repositories Extension - read more: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-repositories-extension.html
    intellijPlatform {
        defaultRepositories()
    }
}

dependencies {
    implementation ('com.github.cliftonlabs:json-simple:4.0.1') {
        exclude group: 'junit'
    }
    implementation('com.offbytwo.jenkins:jenkins-client:0.3.8') {
        exclude group: 'org.slf4j'
        exclude group: 'org.apache.logging.log4j'
        // provided by Idea Platform
        //exclude group: 'commons-io' // not exists in all products (missing in PyCharm e.g)
        exclude group: 'commons-lang'
        exclude group: 'commons-collections'
        exclude group: 'commons-logging'
        exclude group: 'org.apache.httpcomponents'
        exclude group: 'com.fasterxml.jackson.core'
        exclude group: 'jaxen'
    }
    implementation(group: 'xml-apis', name: 'xml-apis', version: '') {
        version {
            strictly "[1.4.01]"
        }
    }
    testImplementation('org.assertj:assertj-swing-junit:3.17.1') {
        exclude group: 'org.assertj', module: 'assertj-core'
        exclude group: 'junit'
    }
    testImplementation(
            platform('org.junit:junit-bom:6.0.1'),
            'org.junit.jupiter:junit-jupiter-api',
            'org.junit.jupiter:junit-jupiter-params',
            'junit:junit:4.13.2',
            'org.mockito:mockito-core:5.+',
            'org.assertj:assertj-core:3.27.6'
    )
    testRuntimeOnly(
            'org.junit.jupiter:junit-jupiter-engine',
            'org.junit.vintage:junit-vintage-engine',
            'org.junit.platform:junit-platform-launcher'
    )
    mockitoAgent('org.mockito:mockito-core:5.+') {
        transitive = false
    }

    // IntelliJ Platform Gradle Plugin Dependencies Extension - read more: https://plugins.jetbrains.com/docs/intellij/tools-intellij-platform-gradle-plugin-dependencies-extension.html
    intellijPlatform {
        create(
                readPropertyString('platformType'),
                readPropertyString("platformVersion")
        )
        //create(IntelliJPlatformType.IntellijIdea, readPropertyString("platformVersion"))

        // Plugin Dependencies. Uses `platformBundledPlugins` property from the gradle.properties file for bundled IntelliJ Platform plugins.
        //bundledPlugins(readPropertyString("platformBundledPlugins").map { it.split(',') })
        bundledPlugins(Arrays.asList(readPropertyString("platformBundledPlugins").split(',')))

        // Plugin Dependencies. Uses `platformPlugins` property from the gradle.properties file for plugin from JetBrains Marketplace.
        //plugins(readPropertyString("platformPlugins").map { it.split(',') })
        plugins(Arrays.asList(readPropertyString("platformPlugins").split(',')))

        // Module Dependencies. Uses `platformBundledModules` property from the gradle.properties file for bundled IntelliJ Platform modules.
        //bundledModules(readPropertyString("platformBundledModules").map { it.split(',') })
        bundledModules(Arrays.asList(readPropertyString("platformBundledModules").split(',')))

        //testFramework(TestFrameworkType.Platform)
        testFramework(TestFrameworkType.Platform.INSTANCE)
    }
}

test {
    useJUnitPlatform()
    jvmArgs '-enableassertions', '-Djava.awt.headless=true'
    testLogging {
        exceptionFormat = 'full'
        showStandardStreams = true
    }
}

runIde {
    jvmArgs = ['-XX:+UnlockDiagnosticVMOptions']
    systemProperty('ide.plugins.snapshot.on.unload.fail', 'true')
    systemProperty('ide.plugins.analyze.snapshot', 'true')
    systemProperty('ide.plugins.allow.unload.from.sources', 'true')
}

def snapshotSpec = copySpec {
    from 'build/distributions'
    include "${readPropertyString('pluginName')}-${project.version}.zip"
}

tasks.register('copyPluginToSnapshots', Copy) {
    into "snapshot"
    with snapshotSpec
}
tasks {
    test {
        //jvmArgs += "-javaagent:${configurations.mockitoAgent.asPath}"
    }
}

copyPluginToSnapshots.dependsOn buildPlugin

prepareSandbox {
    from (['README.md', 'CHANGELOG.md', 'LICENSE.txt']) {
        into "${readPropertyString('pluginName')}/"
    }
}

sonar {
    properties {
        property "sonar.organization", "mcmics-github"
        property "sonar.host.url", "https://sonarcloud.io"
        property "sonar.projectKey", "MCMicS_jenkins-control-plugin"
    }
}

jacocoTestReport {
    dependsOn test
    reports {
        xml.required.set(true)
    }
}

tasks.register('copySignedPluginToSnapshots', () -> {
    copy {
        from 'build/distributions'
        include "${readPropertyString('pluginName')}-${project.version}-signed.zip"
        into "snapshot"
    }
})
copySignedPluginToSnapshots.dependsOn signPlugin

publishPlugin {
    def isRelease = channel == 'default';
    if (isRelease) {
        dependsOn patchChangelog
    }
}
def getChannel(String version) {
    def semVerPreReleaseIndex = version.indexOf('-')
    final preReleaseVersion = semVerPreReleaseIndex != -1 ? version.substring(semVerPreReleaseIndex + 1) : 'default';
    final firstDotInPreRelease = preReleaseVersion.indexOf('.');
    return firstDotInPreRelease == -1 ? preReleaseVersion : preReleaseVersion.substring(0, firstDotInPreRelease);
}