build.gradle

//import org.jetbrains.changelog.ExtensionsKt

import org.jetbrains.changelog.Changelog
import org.jetbrains.changelog.exceptions.MissingVersionException
import org.jetbrains.intellij.tasks.RunPluginVerifierTask

plugins {
    id 'java'
    id 'org.jetbrains.intellij' version '1.17.4'
    id("org.jetbrains.kotlin.jvm") version "2.0.20"
    id 'org.jetbrains.changelog' version '2.2.1'
    id 'org.jetbrains.qodana' version '2024.2.2'
    id "io.freefair.lombok" version "8.10"
    id 'idea'
    id "org.sonarqube" version '5.1.0.4882'
    id 'jacoco'
}
def readPropertyString = (key) -> property(key).toString()

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

intellij {
    pluginName.set(readPropertyString('pluginName'))
    version.set(readPropertyString('platformVersion'))
    type.set(readPropertyString('platformType'))
    configureDefaultDependencies.set(true)
    plugins.set(Arrays.asList(readPropertyString("platformPlugins").split(',')))
}

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
}

lombok {
    version = "1.18.22"
    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")
}
tasks.patchPluginXml {
    version.set(project.version)
    sinceBuild.set(readPropertyString("pluginSinceBuild"))
    untilBuild.set(readPropertyString("pluginUntilBuild"))
    pluginDescription.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() } )
}

configurations {
    provided
}

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

repositories {
    mavenCentral()
    maven { url 'https://www.jetbrains.com/intellij-repository/snapshots' }
}

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:5.11.0'),
            'org.junit.jupiter:junit-jupiter-api',
            'org.junit.jupiter:junit-jupiter-params',
            'junit:junit:4.13.2',
            'org.mockito:mockito-core:5.13.0',
            'org.assertj:assertj-core:3.26.3'
    )
    testRuntimeOnly(
            'org.junit.jupiter:junit-jupiter-engine',
            'org.junit.vintage:junit-vintage-engine',
            'org.junit.platform:junit-platform-launcher'
    )
}

test {
    useJUnitPlatform()
    jvmArgs '-enableassertions', '-Djava.awt.headless=true'
    doFirst {
        systemProperty("idea.plugins.path", project.rootDir.canonicalPath + "/.test-plugins")
    }
    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')
}

buildPlugin {
    doLast {
        copy {
            from 'build/distributions'
            include "${readPropertyString('pluginName')}-${project.version}.zip"
            into "snapshot"
        }
    }
}

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)
    }
}

def ideaVersionToVerify = readPropertyString('platformVersionToVerify')
def verifyFailureLevel = EnumSet.copyOf(RunPluginVerifierTask.FailureLevel.ALL)
verifyFailureLevel.remove(RunPluginVerifierTask.FailureLevel.NOT_DYNAMIC)
runPluginVerifier {
    // filled by task listProductsReleases
    //ideVersions = ["IU-${ideaVersionToVerify}"]
//    ideVersions = ["IC-2020.3", "PS-2020.3", "IU-2020.3"]
    failureLevel = verifyFailureLevel
    verifierVersion = "latest"
}
signPlugin {
    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"))
    doLast {
        copy {
            from 'build/distributions'
            include "${readPropertyString('pluginName')}-${project.version}-signed.zip"
            into "snapshot"
        }
    }
}
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);
}
publishPlugin {
    def channel = getChannel(readPropertyString('pluginVersion'))
    def isRelease = channel == 'default';
    if (isRelease) {
        dependsOn patchChangelog
    }
    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])
}