separation of gradle and maven classes Closes #1616 (#1995)

* separation of gradle and maven classes

* separation of gradle and maven classes

Author: shalom938

.idea/gradle.xml

@@ -62,6 +62,8 @@ dependencies {
     implementation(project(":jvm-common"))
     implementation(project(":python"))
     implementation(project(":rider"))
+    implementation(project(":gradle-support"))
+    implementation(project(":maven-support"))
 
     riderDotNetObjects(project(mapOf(
         "path" to ":rider",

build.gradle.kts

@@ -0,0 +1,23 @@
+import common.IdeFlavor
+import common.logBuildProfile
+import common.platformVersion
+
+plugins {
+    id("plugin-library")
+}
+
+
+dependencies {
+    compileOnly(project(":ide-common"))
+    compileOnly(project(":jvm-common"))
+}
+
+//jvm module should always build with IC
+val platformType by extra(IdeFlavor.IC.name)
+
+logBuildProfile(project)
+
+intellij {
+    version.set("$platformType-${project.platformVersion()}")
+    plugins.set(listOf("com.intellij.java", "org.jetbrains.plugins.gradle"))
+}

gradle-support/build.gradle.kts

@@ -0,0 +1,103 @@
+package org.digma.intellij.plugin.idea.gradle.execution
+
+import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.SimpleProgramParameters
+import com.intellij.util.keyFMap.KeyFMap
+import org.digma.intellij.plugin.idea.execution.ModuleResolver
+import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
+import org.jetbrains.plugins.gradle.service.task.GradleTaskManager
+
+class GradleModuleResolver(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters) : ModuleResolver(configuration, params) {
+
+    override fun findMainClassName(): String? {
+
+        //casting must succeed or we have a bug
+        val myConfiguration = configuration as GradleRunConfiguration
+
+        val mainClass = if (containsGradleTestTask(myConfiguration.settings.taskNames)) {
+            cleanupName(findClassNameFromTestConfiguration(myConfiguration))
+        } else {
+            cleanupName(findClassFromProgramConfiguration(myConfiguration))
+        }
+
+        if (mainClass != null) {
+            return mainClass
+        }
+
+        //try super as last resort
+        return super.findMainClassName()
+    }
+
+
+    private fun findClassNameFromTestConfiguration(configuration: GradleRunConfiguration): String? {
+
+        //taskNames is actually the whole gradle command as in 'gradle :test --tests my.package.MyClass.myMethod'
+        //and could be anything like 'gradle build myOtherTask myProject:test --tests my.package.MyClass.myMethod'
+        //--tests is argument to the test task and must come after it.
+        //we want to find the test name after --tests which may be a class or method name
+        val tasks = configuration.settings.taskNames
+        val hasTestTask = tasks.any {
+            it.equals(":test") ||
+                    it.endsWith(":test") ||
+                    it.equals("test")
+        }
+        val dashTestsIndex = tasks.indexOf("--tests")
+        if (hasTestTask && dashTestsIndex > -1 && tasks.size > dashTestsIndex) {
+            val tests = tasks[dashTestsIndex + 1]
+            if (tests != null) {
+                return tests.trim('\"', '\'').trim()
+            }
+        }
+
+        return null
+    }
+
+
+    private fun findClassFromProgramConfiguration(configuration: GradleRunConfiguration): String? {
+        val confMap: KeyFMap = configuration.get()
+        val gradleScriptContent = confMap.get(GradleTaskManager.INIT_SCRIPT_KEY)
+        return gradleScriptContent?.let {
+            findMainClassNameInGradleScript(it)
+        }
+    }
+
+
+    private fun findMainClassNameInGradleScript(gradleScript: String): String? {
+
+        // search for line like this:
+        //     def mainClassToRun = 'ab.cde.AppMain'
+        val lines = gradleScript.split("\n", "\r", "\r\n")
+
+        val mainClassLine = lines.find { it.contains("mainClassToRun") }
+
+        return mainClassLine?.let { line ->
+            //todo: doesn't look logical
+            val ixLast = line.lastIndexOf('\'')
+            if (ixLast > -1) {
+                val ixFirst = line.lastIndexOf('\'', ixLast - 1)
+                if (ixFirst > -1) {
+                    line.substring(ixFirst + 1, ixLast)
+                } else {
+                    null
+                }
+            } else {
+                null
+            }
+        }
+    }
+
+
+    private fun containsGradleTestTask(gradleTasks: Collection<String>): Boolean {
+        return gradleTasks.any { isGradleTestTask(it) }
+    }
+
+    private fun isGradleTestTask(taskName: String): Boolean =
+        taskName == ":test" ||
+                taskName.endsWith(":test") ||
+                taskName == "test"
+
+
+    private fun cleanupName(className: String?): String? {
+        return className?.replace('$', '.')
+    }
+}

gradle-support/src/main/kotlin/org/digma/intellij/plugin/idea/gradle/execution/GradleModuleResolver.kt

@@ -0,0 +1,129 @@
+package org.digma.intellij.plugin.idea.gradle.execution
+
+import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.RunnerSettings
+import com.intellij.execution.configurations.SimpleProgramParameters
+import org.digma.intellij.plugin.buildsystem.BuildSystem
+import org.digma.intellij.plugin.execution.RunConfigurationType
+import org.digma.intellij.plugin.idea.execution.ConfigurationCleaner
+import org.digma.intellij.plugin.idea.execution.ExternalSystemConfigurationCleaner
+import org.digma.intellij.plugin.idea.execution.ExternalSystemJavaToolOptionsMerger
+import org.digma.intellij.plugin.idea.execution.JavaToolOptionsMerger
+import org.digma.intellij.plugin.idea.execution.ModuleResolver
+import org.digma.intellij.plugin.idea.execution.ParametersExtractor
+import org.digma.intellij.plugin.idea.execution.services.BaseJvmRunConfigurationInstrumentationService
+import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
+
+
+//don't change to light service because it will register always. we want it to register only if gradle is enabled.
+// see org.digma.intellij-with-gradle.xml
+@Suppress("LightServiceMigrationCode")
+class GradleRunConfigurationService : BaseJvmRunConfigurationInstrumentationService() {
+
+    override fun isApplicableFor(configuration: RunConfigurationBase<*>): Boolean {
+        return isApplicable(configuration, null)
+    }
+
+    override fun isApplicableFor(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): Boolean {
+        return isApplicable(configuration, params)
+    }
+
+    private fun isApplicable(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters?): Boolean {
+        if (configuration is GradleRunConfiguration) {
+
+            val taskNames = configuration.settings.taskNames
+
+            val isMainMethod = taskNames.any {
+                it.contains(".main")
+            }
+            val hasBootRun = taskNames.any {
+                it.contains(":bootRun") || it.equals("bootRun")
+            }
+
+            //support for the run task of the java application plugin. https://docs.gradle.org/current/userguide/application_plugin.html
+            val hasRun = taskNames.any {
+                it.contains(":run") || it.equals("run")
+            }
+
+            if (isMainMethod || hasBootRun || hasRun || isTest(configuration, params)) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+
+    override fun isTest(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters?): Boolean {
+        return if (configuration is GradleRunConfiguration) {
+            val taskNames = configuration.settings.taskNames
+            taskNames.any {
+                it.equals(":test") ||
+                        it.endsWith(":test") ||
+                        it.equals("test") ||
+                        it.equals(":bootTestRun") ||
+                        it.endsWith(":bootTestRun") ||
+                        it.equals("bootTestRun")
+            }
+        } else {
+            false
+        }
+    }
+
+
+    override fun getConfigurationType(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): RunConfigurationType {
+        return if (configuration is GradleRunConfiguration) {
+            if (isTest(configuration, params)) {
+                RunConfigurationType.GradleTest
+            } else {
+                RunConfigurationType.GradleRun
+            }
+        } else {
+            RunConfigurationType.Unknown
+        }
+    }
+
+    override fun isHandlingType(configuration: RunConfigurationBase<*>): Boolean {
+        return configuration is GradleRunConfiguration
+    }
+
+    override fun getTaskNames(configuration: RunConfigurationBase<*>): Set<String> {
+        if (configuration is GradleRunConfiguration) {
+            return configuration.settings.taskNames.toSet()
+        }
+        return setOf()
+    }
+
+    override fun getBuildSystem(configuration: RunConfigurationBase<*>): BuildSystem {
+        if (configuration is GradleRunConfiguration) {
+            return BuildSystem.GRADLE
+        }
+        return BuildSystem.INTELLIJ
+    }
+
+    override fun shouldCleanConfigurationAfterStart(configuration: RunConfigurationBase<*>): Boolean {
+        return true
+    }
+
+
+    override fun getModuleResolver(
+        configuration: RunConfigurationBase<*>,
+        params: SimpleProgramParameters,
+        runnerSettings: RunnerSettings?
+    ): ModuleResolver {
+        return GradleModuleResolver(configuration, params)
+    }
+
+
+    override fun getJavaToolOptionsMerger(
+        configuration: RunConfigurationBase<*>,
+        params: SimpleProgramParameters,
+        parametersExtractor: ParametersExtractor
+    ): JavaToolOptionsMerger {
+        return ExternalSystemJavaToolOptionsMerger(configuration, params, parametersExtractor)
+    }
+
+    override fun getConfigurationCleaner(configuration: RunConfigurationBase<*>): ConfigurationCleaner {
+        return ExternalSystemConfigurationCleaner(configuration)
+    }
+}

gradle-support/src/main/kotlin/org/digma/intellij/plugin/idea/gradle/execution/GradleRunConfigurationService.kt

@@ -0,0 +1,14 @@
+package org.digma.intellij.plugin.idea.gradle.helper
+
+import org.digma.intellij.plugin.buildsystem.BuildSystemHelperService
+import org.jetbrains.plugins.gradle.util.GradleConstants
+
+//don't change to light service because it will register always. we want it to register only if gradle is enabled.
+// see org.digma.intellij-with-gradle.xml
+@Suppress("LightServiceMigrationCode")
+class GradleService : BuildSystemHelperService {
+
+    override fun isBuildSystem(externalSystemId: String): Boolean {
+        return GradleConstants.SYSTEM_ID.id.equals(externalSystemId, true)
+    }
+}

gradle-support/src/main/kotlin/org/digma/intellij/plugin/idea/gradle/helper/GradleService.kt

@@ -10,6 +10,7 @@ import com.intellij.util.messages.MessageBusConnection
  * no connection message in the plugin window.
  * see also class NoConnectionPanel
  */
+//todo: change to application service , and AnalyticsServiceConnectionEvent too
 @Service(Service.Level.PROJECT)
 class BackendConnectionMonitor(val project: Project) : Disposable, AnalyticsServiceConnectionEvent {
 

ide-common/src/main/kotlin/org/digma/intellij/plugin/analytics/BackendConnectionMonitor.kt

@@ -0,0 +1,7 @@
+package org.digma.intellij.plugin.buildsystem
+
+enum class BuildSystem {
+    MAVEN,
+    GRADLE,
+    INTELLIJ,
+}

ide-common/src/main/kotlin/org/digma/intellij/plugin/buildsystem/BuildSystem.kt

@@ -0,0 +1,8 @@
+package org.digma.intellij.plugin.buildsystem
+
+interface BuildSystemHelper {
+
+    fun isBuildSystem(externalSystemId: String): Boolean
+    fun getBuildSystem(externalSystemId: String): BuildSystem?
+
+}

ide-common/src/main/kotlin/org/digma/intellij/plugin/buildsystem/BuildSystemHelper.kt

@@ -0,0 +1,7 @@
+package org.digma.intellij.plugin.buildsystem
+
+interface BuildSystemHelperService {
+
+    fun isBuildSystem(externalSystemId: String): Boolean
+
+}