diff --git a/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java b/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java index 92a9924f25883..5eb0c3fd830be 100644 --- a/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java +++ b/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java @@ -50,8 +50,8 @@ public class ApplicationConfiguration extends JavaRunConfigurationBase implements SingleClassConfiguration, RefactoringListenerProvider, InputRedirectAware, TargetEnvironmentAwareRunProfile, FusAwareRunConfiguration, EnvFilesOptions { - /* deprecated, but 3rd-party used variables */ - @SuppressWarnings({"DeprecatedIsStillUsed", "MissingDeprecatedAnnotation"}) + /* deprecated, ~~but 3rd-party used variables~~, can be removed */ + @SuppressWarnings("MissingDeprecatedAnnotation") @Deprecated public String MAIN_CLASS_NAME; @SuppressWarnings({"DeprecatedIsStillUsed", "MissingDeprecatedAnnotation"}) @Deprecated public String PROGRAM_PARAMETERS; diff --git a/java/execution/impl/src/com/intellij/execution/application/JavaApplicationRunConfigurationImporter.kt b/java/execution/impl/src/com/intellij/execution/application/JavaApplicationRunConfigurationImporter.kt index 5ae06a5a4f6da..e734eff5f331e 100644 --- a/java/execution/impl/src/com/intellij/execution/application/JavaApplicationRunConfigurationImporter.kt +++ b/java/execution/impl/src/com/intellij/execution/application/JavaApplicationRunConfigurationImporter.kt @@ -14,30 +14,42 @@ import com.intellij.openapi.project.Project import com.intellij.util.ObjectUtils.consumeIfCast class JavaApplicationRunConfigurationImporter : RunConfigurationImporter { - override fun process(project: Project, runConfiguration: RunConfiguration, cfg: Map, modelsProvider: IdeModifiableModelsProvider) { + @Suppress("UNCHECKED_CAST") + override fun process( + project: Project, + runConfiguration: RunConfiguration, + cfg: Map, + modelsProvider: IdeModifiableModelsProvider, + ) { if (runConfiguration !is ApplicationConfiguration) { throw IllegalArgumentException("Unexpected type of run configuration: ${runConfiguration::class.java}") } - consumeIfCast(cfg["moduleName"], String::class.java) { - val module = modelsProvider.modifiableModuleModel.findModuleByName(it) - if (module != null) { - runConfiguration.setModule(module) - } - } + val moduleName = cfg["moduleName"] as? String + val module = moduleName?.let(modelsProvider.modifiableModuleModel::findModuleByName) + if (module != null) { + runConfiguration.setModule(module) + } - consumeIfCast(cfg["mainClass"], String::class.java) { runConfiguration.mainClassName = it } - consumeIfCast(cfg["jvmArgs"], String::class.java) { runConfiguration.vmParameters = it } - consumeIfCast(cfg["programParameters"], String::class.java) { runConfiguration.programParameters = it } - consumeIfCast(cfg["envs"], Map::class.java) { runConfiguration.envs = it as MutableMap } - consumeIfCast(cfg["workingDirectory"], String::class.java) { runConfiguration.workingDirectory = it } - runConfiguration.setIncludeProvidedScope(cfg["includeProvidedDependencies"] as? Boolean ?: false) - - consumeIfCast(cfg["shortenCommandLine"], String::class.java) { - try { - runConfiguration.shortenCommandLine = ShortenCommandLine.valueOf(it) - } catch (e: IllegalArgumentException) { - LOG.warn("Illegal value of 'shortenCommandLine': $it", e) + val jrePath = (cfg["alternativeJrePath"] as? String)?.takeIf { it.isNotEmpty() } + val shortenCmdLine = cfg["shortenCommandLine"] as? String + with(runConfiguration) { + mainClassName = cfg["mainClass"] as? String + vmParameters = cfg["jvmArgs"] as? String + programParameters = cfg["programParameters"] as? String + envs = cfg["envs"] as? MutableMap ?: mutableMapOf() + workingDirectory = cfg["workingDirectory"] as? String + setIncludeProvidedScope(cfg["includeProvidedDependencies"] as? Boolean ?: false) + isAlternativeJrePathEnabled = jrePath != null + alternativeJrePath = jrePath + + if (shortenCmdLine != null) { + try { + shortenCommandLine = ShortenCommandLine.valueOf(shortenCmdLine) + } + catch (e: IllegalArgumentException) { + LOG.warn("Illegal value of 'shortenCommandLine': $shortenCmdLine", e) + } } } } @@ -50,6 +62,6 @@ class JavaApplicationRunConfigurationImporter : RunConfigurationImporter { .configurationFactories[0] companion object { - val LOG = Logger.getInstance(JavaApplicationRunConfigurationImporter::class.java) + val LOG: Logger = Logger.getInstance(JavaApplicationRunConfigurationImporter::class.java) } } \ No newline at end of file diff --git a/java/execution/impl/src/com/intellij/execution/jar/JarApplicationRunConfigurationImporter.kt b/java/execution/impl/src/com/intellij/execution/jar/JarApplicationRunConfigurationImporter.kt index 9c887cbe38029..4bfcd84fd3ab0 100644 --- a/java/execution/impl/src/com/intellij/execution/jar/JarApplicationRunConfigurationImporter.kt +++ b/java/execution/impl/src/com/intellij/execution/jar/JarApplicationRunConfigurationImporter.kt @@ -7,28 +7,34 @@ import com.intellij.execution.configurations.RunConfiguration import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider import com.intellij.openapi.externalSystem.service.project.settings.RunConfigurationImporter import com.intellij.openapi.project.Project -import com.intellij.util.ObjectUtils.consumeIfCast class JarApplicationRunConfigurationImporter : RunConfigurationImporter { - - override fun process(project: Project, - runConfiguration: RunConfiguration, - cfg: MutableMap, - modelsProvider: IdeModifiableModelsProvider) { + @Suppress("UNCHECKED_CAST") + override fun process( + project: Project, + runConfiguration: RunConfiguration, + cfg: MutableMap, + modelsProvider: IdeModifiableModelsProvider, + ) { if (runConfiguration !is JarApplicationConfiguration) { throw IllegalArgumentException("Unexpected type of run configuration: ${runConfiguration::class.java}") } - consumeIfCast(cfg["moduleName"], String::class.java) { - val module = modelsProvider.modifiableModuleModel.findModuleByName(it) - if (module != null) { - runConfiguration.module = module - } + val moduleName = cfg["moduleName"] as? String + val module = moduleName?.let(modelsProvider.modifiableModuleModel::findModuleByName) + + if (module != null) { + runConfiguration.module = module + } + val jrePath = (cfg["alternativeJrePath"] as? String)?.takeIf { it.isNotEmpty() } + with(runConfiguration) { + jarPath = cfg["jarPath"] as? String ?: "" + vmParameters = cfg["jvmArgs"] as? String ?: "" + programParameters = cfg["programParameters"] as? String ?: "" + workingDirectory = cfg["workingDirectory"] as? String ?: "" + envs = cfg["envs"] as? Map ?: emptyMap() + isAlternativeJrePathEnabled = jrePath != null + alternativeJrePath = jrePath } - consumeIfCast(cfg["jarPath"], String::class.java) { runConfiguration.jarPath = it } - consumeIfCast(cfg["jvmArgs"], String::class.java) { runConfiguration.vmParameters = it } - consumeIfCast(cfg["programParameters"], String::class.java) { runConfiguration.programParameters = it } - consumeIfCast(cfg["workingDirectory"], String::class.java) { runConfiguration.workingDirectory = it } - consumeIfCast(cfg["envs"], Map::class.java) { runConfiguration.envs = it as MutableMap } } override fun canImport(typeName: String): Boolean = typeName == "jarApplication" diff --git a/java/java-tests/testSrc/com/intellij/java/execution/ApplicationModulePathTest.java b/java/java-tests/testSrc/com/intellij/java/execution/ApplicationModulePathTest.java index e9ff2213e617c..dbcbdfc8422be 100644 --- a/java/java-tests/testSrc/com/intellij/java/execution/ApplicationModulePathTest.java +++ b/java/java-tests/testSrc/com/intellij/java/execution/ApplicationModulePathTest.java @@ -108,7 +108,7 @@ public void testExcludedModuleInfo() throws ExecutionException { public void testLightModule() throws ExecutionException { ApplicationConfiguration configuration = setupConfiguration(getTestName(true), myModule); - configuration.MAIN_CLASS_NAME = "my.test.launcher.Launcher"; + configuration.setMainClassName("my.test.launcher.Launcher"); VirtualFile moduleInfoFile = getContentRoot(getTestName(true)) .findFileByRelativePath("src/module-info.java"); diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleSettingsImportingTest.java b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleSettingsImportingTest.java index 244e2070cdf5f..a8159cd6cb77a 100644 --- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleSettingsImportingTest.java +++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleSettingsImportingTest.java @@ -9,6 +9,7 @@ import com.intellij.execution.application.ApplicationConfiguration; import com.intellij.execution.application.JavaApplicationRunConfigurationImporter; import com.intellij.execution.configurations.RunConfiguration; +import com.intellij.execution.jar.JarApplicationConfiguration; import com.intellij.execution.jar.JarApplicationRunConfigurationImporter; import com.intellij.ide.impl.ProjectUtil; import com.intellij.openapi.application.Application; @@ -81,41 +82,50 @@ public void testInspectionSettingsImport() throws Exception { @Test @TargetVersions("4.7+") // The idea ext plugin is only compatible with Gradle 4.7+ public void testApplicationRunConfigurationSettingsImport() throws Exception { - TestRunConfigurationImporter testExtension = new TestRunConfigurationImporter("application"); - maskRunImporter(testExtension); + JavaApplicationRunConfigurationImporter appConfigImporter = new JavaApplicationRunConfigurationImporter(); + maskRunImporter(appConfigImporter); createSettingsFile("rootProject.name = 'moduleName'"); importProject( - withGradleIdeaExtPlugin( - """ - import org.jetbrains.gradle.ext.* - idea { - project.settings { - runConfigurations { - app1(Application) { - mainClass = 'my.app.Class' - jvmArgs = '-Xmx1g' - moduleName = 'moduleName' - } - app2(Application) { - mainClass = 'my.app.Class2' - moduleName = 'moduleName' - } + createBuildScriptBuilder() + .withGradleIdeaExtPluginIfCan() + .addPostfix( + """ + import org.jetbrains.gradle.ext.* + idea { + project.settings { + runConfigurations { + app1(Application) { + mainClass = 'my.app.Class' + jvmArgs = '-Xmx1g' + moduleName = 'moduleName' + alternativeJrePath = 'myAltJrePath' + } + app2(Application) { + mainClass = 'my.app.Class2' + moduleName = 'moduleName' + } + } } - } - }""") - ); - - final Map> configs = testExtension.getConfigs(); - - assertContain(new ArrayList<>(configs.keySet()), "app1", "app2"); - Map app1Settings = configs.get("app1"); - Map app2Settings = configs.get("app2"); + }""" + ).generate()); - assertEquals("my.app.Class", app1Settings.get("mainClass")); - assertEquals("my.app.Class2", app2Settings.get("mainClass")); - assertEquals("-Xmx1g", app1Settings.get("jvmArgs")); - assertNull(app2Settings.get("jvmArgs")); + final RunManager runManager = RunManager.getInstance(getMyProject()); + final RunnerAndConfigurationSettings app1Template = runManager.findConfigurationByName("app1"); + final RunnerAndConfigurationSettings app2Template = runManager.findConfigurationByName("app2"); + assertNotNull(app1Template); + assertNotNull(app2Template); + final ApplicationConfiguration app1 = assertInstanceOf(app1Template.getConfiguration(), ApplicationConfiguration.class); + final ApplicationConfiguration app2 = assertInstanceOf(app2Template.getConfiguration(), ApplicationConfiguration.class); + + assertEquals("my.app.Class", app1.getMainClassName()); + assertEquals("my.app.Class2", app2.getMainClassName()); + assertEquals("-Xmx1g", app1.getVMParameters()); + assertEquals("myAltJrePath", app1.getAlternativeJrePath()); + assertTrue(app1.isAlternativeJrePathEnabled()); + assertNull(app2.getVMParameters()); + assertNull(app2.getAlternativeJrePath()); + assertFalse(app2.isAlternativeJrePathEnabled()); } @Test @@ -272,40 +282,49 @@ public void testBeforeRunTaskImport() throws Exception { @Test @TargetVersions("4.7+") // The idea ext plugin is only compatible with Gradle 4.7+ public void testJarApplicationRunConfigurationSettingsImport() throws Exception { - TestRunConfigurationImporter testExtension = new TestRunConfigurationImporter("jarApplication"); - maskRunImporter(testExtension); + JarApplicationRunConfigurationImporter jarAppConfigImporter = new JarApplicationRunConfigurationImporter(); + maskRunImporter(jarAppConfigImporter); createSettingsFile("rootProject.name = 'moduleName'"); importProject( createBuildScriptBuilder() - .withGradleIdeaExtPluginIfCan() - .addPostfix( - "import org.jetbrains.gradle.ext.*", - "idea.project.settings {", - " runConfigurations {", - " jarApp1(JarApplication) {", - " jarPath = 'my/app.jar'", - " jvmArgs = '-DvmKey=vmVal'", - " moduleName = 'moduleName'", - " }", - " jarApp2(JarApplication) {", - " jarPath = 'my/app2.jar'", - " moduleName = 'moduleName'", - " }", - " }", - "}" - ).generate()); - - final Map> configs = testExtension.getConfigs(); - - assertContain(new ArrayList<>(configs.keySet()), "jarApp1", "jarApp2"); - Map jarApp1Settings = configs.get("jarApp1"); - Map jarApp2Settings = configs.get("jarApp2"); + .withGradleIdeaExtPluginIfCan() + .addPostfix( + "import org.jetbrains.gradle.ext.*", + "idea.project.settings {", + " runConfigurations {", + " jarApp1(JarApplication) {", + " jarPath = 'my/app.jar'", + " jvmArgs = '-DvmKey=vmVal'", + " moduleName = 'moduleName'", + " alternativeJrePath = 'myAltJrePath'", + " }", + " jarApp2(JarApplication) {", + " jarPath = 'my/app2.jar'", + " moduleName = 'moduleName'", + " }", + " }", + "}" + ).generate()); - assertEquals("my/app.jar", jarApp1Settings.get("jarPath")); - assertEquals("my/app2.jar", jarApp2Settings.get("jarPath")); - assertEquals("-DvmKey=vmVal", jarApp1Settings.get("jvmArgs")); - assertNull(jarApp2Settings.get("jvmArgs")); + RunManager runManager = RunManager.getInstance(getMyProject()); + RunnerAndConfigurationSettings jarApp1Template = runManager.findConfigurationByName("jarApp1"); + RunnerAndConfigurationSettings jarApp2Template = runManager.findConfigurationByName("jarApp2"); + assertNotNull(jarApp1Template); + assertNotNull(jarApp2Template); + JarApplicationConfiguration jarApp1 = assertInstanceOf(jarApp1Template.getConfiguration(), JarApplicationConfiguration.class); + JarApplicationConfiguration jarApp2 = assertInstanceOf(jarApp2Template.getConfiguration(), JarApplicationConfiguration.class); + + assertEquals("my/app.jar", jarApp1.getJarPath()); + assertEquals("my/app2.jar", jarApp2.getJarPath()); + assertEquals("-DvmKey=vmVal", jarApp1.getVMParameters()); + assertEquals("myAltJrePath", jarApp1.getAlternativeJrePath()); + assertEmpty(jarApp2.getVMParameters()); + assertTrue(jarApp1.isAlternativeJrePathEnabled()); + assertEmpty(jarApp2.getAlternativeJrePath()); + assertEmpty(jarApp2.getVMParameters()); + assertEmpty(jarApp2.getAlternativeJrePath()); + assertFalse(jarApp2.isAlternativeJrePathEnabled()); } @Test diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/TestGradleBuildScriptBuilder.kt b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/TestGradleBuildScriptBuilder.kt index c2e98f01aa535..5b5df9e402f93 100644 --- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/TestGradleBuildScriptBuilder.kt +++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/TestGradleBuildScriptBuilder.kt @@ -89,7 +89,7 @@ open class TestGradleBuildScriptBuilder( fun withLocalGradleIdeaExtPlugin(jarFile: File) = apply { withBuildScriptMavenCentral() - addBuildScriptClasspath(call("file", jarFile.absolutePath)) + addBuildScriptClasspath(call("files", jarFile.absolutePath)) addBuildScriptClasspath("com.google.code.gson:gson:2.8.2") addBuildScriptClasspath("com.google.guava:guava:25.1-jre") applyPlugin("org.jetbrains.gradle.plugin.idea-ext")