build.gradle

import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType
import org.jetbrains.intellij.platform.gradle.TestFrameworkType
import org.jetbrains.intellij.platform.gradle.tasks.RunIdeTask

plugins {
    id "org.jetbrains.intellij.platform" version "2.0.1"
    id "org.jetbrains.kotlin.jvm" version "1.9.24"
    id "de.undercouch.download" version "4.1.2"
    id 'com.adarshr.test-logger' version '4.0.0'
}

apply plugin: "org.jetbrains.intellij.platform"

ext {
    cachePath = "${rootDir}/cache"

    elixirPath = "${cachePath}/elixir-${elixirVersion}"

    quoterVersion = "2.1.0"

    quoterUnzippedPath = "${cachePath}/elixir-${elixirVersion}-intellij_elixir-${quoterVersion}"
    quoterReleasePath = "${quoterUnzippedPath}/_build/dev/rel/intellij_elixir"
    quoterExe = "${quoterReleasePath}/bin/intellij_elixir"
    quoterZipPath = "${cachePath}/intellij_elixir-${quoterVersion}.zip"
    quoterZipRootPath = "${cachePath}/intellij_elixir-${quoterVersion}"

    if (project.hasProperty("isRelease") && isRelease) {
        versionSuffix = ""
        channel = "default"
    } else {
        def date = new Date().format("yyyyMMddHHmmss", TimeZone.getTimeZone("UTC"))
        versionSuffix = "-pre+$date"
        channel = "canary"
    }

    version "$pluginVersion$versionSuffix"
}

allprojects {
    apply plugin: 'java'
    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion
    tasks.withType(JavaCompile) { options.encoding = 'UTF-8' }
}
subprojects {
    apply plugin: 'org.jetbrains.intellij.platform.module'
    repositories {
        mavenCentral()
        intellijPlatform {
            defaultRepositories()
        }
    }
    dependencies {
        testImplementation 'junit:junit:4.13.2'
        testImplementation "org.opentest4j:opentest4j:1.3.0"

        intellijPlatform {
            create(providers.gradleProperty("platformType"), providers.gradleProperty("platformVersion"))

            bundledPlugins providers.gradleProperty("platformBundledPlugins").map { it.split(',').toList() }
            plugins providers.gradleProperty("platformPlugins").map { it.split(',').toList() }

            instrumentationTools()
            pluginVerifier()
            zipSigner()
            testFramework(TestFrameworkType.Platform.INSTANCE)
            testFramework(TestFrameworkType.Plugin.Java.INSTANCE)
        }
    }
    sourceSets {
        main {
            java.srcDirs 'src'
            resources.srcDirs 'resources'
        }
        test {
            java.srcDir 'tests'
        }
    }

}
sourceSets {
    main {
        java.srcDirs 'src', 'gen'
        resources.srcDirs 'resources'
    }
    test {
        java.srcDir 'tests'
    }
}
intellijPlatform {
    pluginConfiguration {
        def stripTag = { text, tag -> text.replace("<${tag}>", "").replace("</${tag}>", "") }
        def bodyInnerHTML = { path ->
            stripTag(stripTag(file(path).text, "html"), "body")
        }

        id = providers.gradleProperty("pluginGroup")
        name = providers.gradleProperty("pluginName")
        version = providers.gradleProperty("pluginVersion")
        changeNotes.set(bodyInnerHTML("resources/META-INF/changelog.html"))
        description.set(bodyInnerHTML("resources/META-INF/description.html"))

        ideaVersion {
            sinceBuild = providers.gradleProperty("pluginSinceBuild")
            untilBuild = providers.gradleProperty("pluginUntilBuild")
        }
        vendor {
            name = providers.gradleProperty("vendorName")
            email = providers.gradleProperty("vendorEmail")
            url = providers.gradleProperty("pluginRepositoryUrl")
        }
    }

    publishPlugin {
        token = provider {
            System.getenv("JET_BRAINS_MARKETPLACE_TOKEN")
        }
        channels = publishChannels.split(',').toList()
        archiveFile = layout.buildDirectory.file("distributions/${System.getenv("ASSET_NAME")}")
    }
    pluginVerification {
        ides {
            ide(IntelliJPlatformType.IntellijIdeaCommunity, "2024.2.0.1")
        }
    }
}
apply plugin: "kotlin"

tasks.withType(RunIdeTask) {
    // Set JVM arguments
    jvmArguments.addAll(["-Didea.debug.mode=true", "-Didea.is.internal=true", "-Dlog4j2.debug=true", "-Dlogger.org=TRACE", "-XX:+AllowEnhancedClassRedefinition"])

    // Set system properties to debug log
    systemProperty "idea.log.debug.categories", "org.elixir_lang"

    // Set the maximum heap size
    maxHeapSize = "7g"

    // Optionally set the working directory if specified in the project properties
    if (project.hasProperty("runIdeWorkingDirectory") && !project.property("runIdeWorkingDirectory").isEmpty()) {
        workingDir = file(project.property("runIdeWorkingDirectory"))
    }
}

//noinspection GroovyAssignabilityCheck,GrUnresolvedAccess
tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    //noinspection GrUnresolvedAccess
    kotlinOptions {
        apiVersion = "1.7"
        jvmTarget = "21"
        freeCompilerArgs = ["-Xjvm-default=all"]
    }
}

def compilationPackages = ['org/intellij/elixir/build/**', 'org/intellij/elixir/jps/**']

test {
    environment "ELIXIR_LANG_ELIXIR_PATH", elixirPath
    environment "ELIXIR_EBIN_DIRECTORY", "${elixirPath}/lib/elixir/ebin/"
    environment "ELIXIR_VERSION", elixirVersion
    setScanForTestClasses(false)
    include("**/Issue*.class")
    include("**/*Test.class")
    include("**/*TestCase.class")
    useJUnit {
        exclude compilationPackages
    }
    testLogging {
        exceptionFormat = 'full'
    }
}

intellijPlatformTesting {
    // Get the list of platforms from gradle.properties
    def platformsList = providers.gradleProperty("platformsList").get().split(",")

    // Use providers.gradleProperty to get the 'runIdePlugins' property
    def runIdePluginsProperty = providers.gradleProperty("runIdePlugins").getOrElse("")
    def runIdePluginsList = runIdePluginsProperty.split(",")

    platformsList.each { platform ->
        runIde.create("run${platform}") {
            type = IntelliJPlatformType."${platform}"
            version = providers.gradleProperty("platformVersion${platform}").get()
            prepareSandboxTask {
                sandboxDirectory = project.layout.buildDirectory.dir("${platform.toLowerCase()}-sandbox")
            }

            // if runIdePluginsList is not empty, set the plugins
            if (runIdePluginsList.size() > 0) {
                plugins {
                    // Apply each plugin from the 'runIdePluginsList'
                    runIdePluginsList.each { plugin ->
                        plugins(plugin.trim())
                    }
                }
            }
        }
    }
}

task testCompilation(type: Test, group: 'Verification', dependsOn: [classes, testClasses]) {
    useJUnit {
        include compilationPackages
    }
    testLogging {
        exceptionFormat = 'full'
    }
}

repositories {
    maven { url 'https://maven-central.storage.googleapis.com' }
    mavenCentral()
    intellijPlatform {
        defaultRepositories()
    }
}

dependencies {
    intellijPlatform {
        create(providers.gradleProperty("platformType"), providers.gradleProperty("platformVersion"))

        bundledPlugins providers.gradleProperty("platformBundledPlugins").map { it.split(',').toList() }
        plugins providers.gradleProperty("platformPlugins").map { it.split(',').toList() }

        instrumentationTools()
        pluginVerifier()
        zipSigner()
        testFramework(TestFrameworkType.Platform.INSTANCE)
        testFramework(TestFrameworkType.Plugin.Java.INSTANCE)
    }

    implementation project(':jps-builder')
    implementation project(':jps-shared')
    implementation files('lib/OtpErlang.jar')
    implementation group: 'commons-io', name: 'commons-io', version: '2.5'

    testImplementation 'junit:junit:4.13.2'
    testImplementation "org.opentest4j:opentest4j:1.3.0"

    testImplementation group: 'org.mockito', name: 'mockito-core', version: '2.2.9'
    testImplementation group: 'org.objenesis', name: 'objenesis', version: '2.4'
}
compileJava {
    dependsOn ':jps-shared:composedJar'
    dependsOn ':jps-builder:composedJar'
}

apply plugin: 'idea'
idea {
    project {
        jdkName = javaVersion
        languageLevel = javaVersion
    }
    module {
        generatedSourceDirs += file('gen')
    }
}

task getElixir {
    doLast {
        def folder = new File(elixirPath)

        if (!folder.isDirectory() || folder.list().size() == 0) {
            download {
                src "https://github.com/elixir-lang/elixir/archive/v${elixirVersion}.zip"
                dest "${rootDir}/cache/Elixir.${elixirVersion}.zip"
                overwrite false
            }
        }

        def binFolder = new File("${elixirPath}/bin")
        if (!binFolder.isDirectory() || folder.list().size() == 0) {
            copy {
                from zipTree("${rootDir}/cache/Elixir.${elixirVersion}.zip")
                into "${rootDir}/cache/"
            }

            exec {
                workingDir elixirPath
                commandLine "make"
            }
        }
    }
}

task getQuoter {
    doLast {
        download {
            src "https://github.com/KronicDeth/intellij_elixir/archive/v${quoterVersion}.zip"
            dest quoterZipPath
            overwrite false
        }

        def folder = new File(quoterUnzippedPath)
        if (!folder.isDirectory() || folder.list().size() == 0) {
            copy {
                from zipTree(quoterZipPath)
                into cachePath
            }

            def quoterZipRootFile = new File(quoterZipRootPath)

            quoterZipRootFile.renameTo(quoterUnzippedPath)
        }
    }
}

task getQuoterDeps(dependsOn: getQuoter) {
    doLast {
        exec {
            workingDir quoterUnzippedPath
            commandLine 'mix', 'do', 'local.rebar', '--force,', 'local.hex', '--force,', 'deps.get'
            // standardOutput = System.out
            // errorOutput = System.err
        }
    }
}

task releaseQuoter(dependsOn: getQuoterDeps) {
    doLast {
        def file = new File(quoterExe)

        if (!file.canExecute()) {
            exec {
                workingDir quoterUnzippedPath
                commandLine 'mix', 'do', 'local.rebar', '--force,', 'local.hex', '--force,', 'deps.get,', 'release'
                // standardOutput = System.out
                // errorOutput = System.err
            }
        }
    }
}

compileTestJava {
    dependsOn ":jps-builder:composedJar"
    dependsOn ":jps-shared:composedJar"
    dependsOn getElixir
    dependsOn getQuoter
}

task runQuoter(type: Exec, dependsOn: releaseQuoter) {
    environment "RELEASE_COOKIE", "intellij_elixir"
    environment "RELEASE_DISTRIBUTION", "name"
    environment "RELEASE_NAME", "intellij_elixir@127.0.0.1"
    executable quoterExe
    args "daemon"
}

task stopQuoter(type: Exec, dependsOn: releaseQuoter) {
    environment "RELEASE_COOKIE", "intellij_elixir"
    environment "RELEASE_DISTRIBUTION", "name"
    environment "RELEASE_NAME", "intellij_elixir@127.0.0.1"
    executable quoterExe
    args "stop"
}

runIde {
    systemProperty "idea.log.debug.categories", "org.elixir_lang=TRACE"
    // When wanting to disable EDT slow assertion..
    // systemProperty "ide.slow.operations.assertion", "true"

    // -Didea.debug.mode=true:
    // This enables debug mode for IntelliJ IDEA. It can be useful when developing plugins to get more detailed logging and debugging information.
    // -Didea.is.internal=true:
    // This flag indicates that the plugin is running in an internal mode, which may enable additional features or logging that are typically only available to IntelliJ developers.
    // -Dlog4j2.debug=true:
    // This enables debug logging for Log4j 2, which is the logging framework used by IntelliJ IDEA. It can help in troubleshooting logging-related issues in your plugin.
    // -Dlogger.org=TRACE:
    // This sets the logging level for the "org" package to TRACE, which is the most verbose logging level. This can be useful for detailed logging of plugin activities.
    // -XX:+AllowEnhancedClassRedefinition:
    // This is a JVM flag that allows for more flexible class redefinition during runtime. It can be beneficial for hot-swapping code changes without restarting the IDE.
    // -Didea.ProcessCanceledException=disabled:
    //This disables the throwing of ProcessCanceledException, which is typically used to cancel long-running processes in IntelliJ IDEA. Disabling it can be useful in certain debugging scenarios.
    jvmArgs "-Didea.debug.mode=true", "-XX:+AllowEnhancedClassRedefinition", "-Didea.is.internal=true", "-Dlog4j2.debug=true", "-Dlogger.org=TRACE", "-Didea.ProcessCanceledException=disabled"
    maxHeapSize = "7g"
    // get from runIdeWorkingDirectory
    if (project.hasProperty("runIdeWorkingDirectory") && !project.property("runIdeWorkingDirectory").isEmpty()) {
        workingDir = file(project.property("runIdeWorkingDirectory"))
    }
}

test {
    dependsOn runQuoter
    finalizedBy stopQuoter
}

apply plugin: 'idea'
idea {
    project {
        jdkName = javaVersion
        languageLevel = javaVersion
    }
    module {
        generatedSourceDirs += file('gen')
    }
}