diff --git a/plugins/gradle/java/src/execution/build/GradleProjectTaskRunner.java b/plugins/gradle/java/src/execution/build/GradleProjectTaskRunner.java index e161818bea2f..347454be5c8e 100644 --- a/plugins/gradle/java/src/execution/build/GradleProjectTaskRunner.java +++ b/plugins/gradle/java/src/execution/build/GradleProjectTaskRunner.java @@ -47,9 +47,9 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.plugins.gradle.service.project.GradleBuildSrcProjectsResolver; import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverUtil; +import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService; import org.jetbrains.plugins.gradle.service.task.GradleTaskManager; import org.jetbrains.plugins.gradle.settings.GradleSettings; -import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings; import org.jetbrains.plugins.gradle.util.GradleConstants; import java.io.File; @@ -179,7 +179,7 @@ public class GradleProjectTaskRunner extends ProjectTaskRunner { public boolean canRun(@NotNull ProjectTask projectTask) { if (projectTask instanceof ModuleBuildTask) { Module module = ((ModuleBuildTask)projectTask).getModule(); - if (!GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabled(module)) return false; + if (!GradleSettingsService.isDelegatedBuildEnabled(module)) return false; return isExternalSystemAwareModule(GradleConstants.SYSTEM_ID, module); } if (projectTask instanceof ProjectModelBuildTask) { @@ -196,13 +196,10 @@ public class GradleProjectTaskRunner extends ProjectTaskRunner { if (runProfile instanceof ModuleBasedConfiguration) { RunConfigurationModule module = ((ModuleBasedConfiguration)runProfile).getConfigurationModule(); if (!isExternalSystemAwareModule(GradleConstants.SYSTEM_ID, module.getModule()) || - !GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabled(module.getModule())) { + !GradleSettingsService.isDelegatedBuildEnabled(module.getModule())) { return false; } } - else if (!GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabledByDefault()) { - return false; - } for (GradleExecutionEnvironmentProvider environmentProvider : GradleExecutionEnvironmentProvider.EP_NAME.getExtensions()) { if (environmentProvider.isApplicable(((ExecuteRunConfigurationTask)projectTask))) { return true; diff --git a/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java b/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java index a4a7b9bbffd0..4df21e3bd739 100644 --- a/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java +++ b/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java @@ -30,13 +30,14 @@ import org.jetbrains.plugins.gradle.execution.GradleRunnerUtil; import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration; import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverUtil; import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames; -import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings; +import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService; +import org.jetbrains.plugins.gradle.settings.TestRunner; import org.jetbrains.plugins.gradle.util.GradleConstants; import java.util.List; import static com.intellij.openapi.util.text.StringUtil.endsWithChar; -import static org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings.PreferredTestRunner.*; +import static org.jetbrains.plugins.gradle.settings.TestRunner.*; /** * @author Vladislav.Soroka @@ -51,13 +52,13 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio @Override public boolean isPreferredConfiguration(ConfigurationFromContext self, ConfigurationFromContext other) { - GradleSystemRunningSettings.PreferredTestRunner testRunner = getTestRunner(self.getSourceElement()); - return testRunner == CHOOSE_PER_TEST || testRunner == GRADLE_TEST_RUNNER; + TestRunner testRunner = getTestRunner(self.getSourceElement()); + return testRunner == CHOOSE_PER_TEST || testRunner == GRADLE; } @Override public boolean shouldReplace(@NotNull ConfigurationFromContext self, @NotNull ConfigurationFromContext other) { - return getTestRunner(self.getSourceElement()) == GRADLE_TEST_RUNNER; + return getTestRunner(self.getSourceElement()) == GRADLE; } @Override @@ -67,8 +68,8 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio if (!GradleConstants.SYSTEM_ID.equals(configuration.getSettings().getExternalSystemId())) return false; if (sourceElement.isNull()) return false; - GradleSystemRunningSettings.PreferredTestRunner testRunner = getTestRunner(sourceElement.get()); - if (testRunner == PLATFORM_TEST_RUNNER) return false; + TestRunner testRunner = getTestRunner(sourceElement.get()); + if (testRunner == PLATFORM) return false; if (configuration instanceof GradleRunConfiguration) { final GradleRunConfiguration gradleRunConfiguration = (GradleRunConfiguration)configuration; gradleRunConfiguration.setScriptDebugEnabled(false); @@ -82,13 +83,12 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio @Override public boolean isConfigurationFromContext(ExternalSystemRunConfiguration configuration, ConfigurationContext context) { - if (GradleSystemRunningSettings.getInstance().getDefaultTestRunner() == PLATFORM_TEST_RUNNER) return false; if (configuration == null) return false; if (!GradleConstants.SYSTEM_ID.equals(configuration.getSettings().getExternalSystemId())) return false; String projectPath = configuration.getSettings().getExternalProjectPath(); - GradleSystemRunningSettings.PreferredTestRunner testRunner = getTestRunner(context.getProject(), projectPath); - if (testRunner == PLATFORM_TEST_RUNNER) return false; + TestRunner testRunner = getTestRunner(context.getProject(), projectPath); + if (testRunner == PLATFORM) return false; return doIsConfigurationFromContext(configuration, context); } @@ -150,19 +150,19 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio return ContainerUtil.map(tasks, task -> taskPrefix + task); } - private static GradleSystemRunningSettings.PreferredTestRunner getTestRunner(@NotNull Project project, @NotNull String projectPath) { - return GradleSystemRunningSettings.getInstance().getTestRunner(project, projectPath); + private static TestRunner getTestRunner(@NotNull Project project, @NotNull String projectPath) { + return GradleSettingsService.getInstance(project).getTestRunner(projectPath); } - private static GradleSystemRunningSettings.PreferredTestRunner getTestRunner(@NotNull PsiElement sourceElement) { + private static TestRunner getTestRunner(@NotNull PsiElement sourceElement) { PsiFile containingFile = sourceElement.getContainingFile(); if (containingFile != null) { VirtualFile file = containingFile.getVirtualFile(); Module module = file == null ? null : ProjectFileIndex.SERVICE.getInstance(sourceElement.getProject()).getModuleForFile(file); if (module != null) { - return GradleSystemRunningSettings.getInstance().getTestRunner(module); + return GradleSettingsService.getTestRunner(module); } } - return GradleSystemRunningSettings.getInstance().getDefaultTestRunner(); + return PLATFORM; } } diff --git a/plugins/gradle/plugin-resources/META-INF/plugin.xml b/plugins/gradle/plugin-resources/META-INF/plugin.xml index 1aa7f6d497f3..e33b78d8a84e 100644 --- a/plugins/gradle/plugin-resources/META-INF/plugin.xml +++ b/plugins/gradle/plugin-resources/META-INF/plugin.xml @@ -73,9 +73,9 @@ instance="org.jetbrains.plugins.gradle.service.settings.GradleConfigurable" key="gradle.name" bundle="i18n.GradleBundle"> - + @@ -93,8 +93,10 @@ + + diff --git a/plugins/gradle/resources/i18n/GradleBundle.properties b/plugins/gradle/resources/i18n/GradleBundle.properties index f8b71ef94944..003452c2efab 100644 --- a/plugins/gradle/resources/i18n/GradleBundle.properties +++ b/plugins/gradle/resources/i18n/GradleBundle.properties @@ -11,7 +11,7 @@ gradle.settings.text.use.gradle.aware.make=Delegate IDE build/run actions to gra gradle.settings.text.delegate.panel.title=Delegate settings gradle.settings.text.delegate.buildRun=Build and run using gradle.settings.text.delegate.testRunner=Run tests using -gradle.settings.text.use.application.default=Use application default +gradle.settings.text.use.default=Use default gradle.settings.text.home.path=Gradle home: gradle.settings.text.jvm.path=Gradle JVM: @@ -49,8 +49,8 @@ gradle.codeInsight.action.add_maven_dependency.description=Add selected maven ar gradle.runner=Runner gradle.runner.toggle.tree.text.action.name=Toggle tasks executions/text mode gradle.preferred_test_runner.CHOOSE_PER_TEST=Choose per test -gradle.preferred_test_runner.PLATFORM_TEST_RUNNER=Platform Test Runner -gradle.preferred_test_runner.GRADLE_TEST_RUNNER=Gradle Test Runner +gradle.preferred_test_runner.PLATFORM=Platform Test Runner +gradle.preferred_test_runner.GRADLE=Gradle Test Runner gradle.test.runner.ui.tests.tree.presentation.labels.waiting.tests=Waiting for tests... gradle.test.runner.ui.tests.tree.presentation.labels.no.tests.were.found=Test events were not received gradle.test.runner.ui.tests.actions.open.gradle.report.text=Open Gradle test report diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/GradleOrderEnumeratorHandler.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/GradleOrderEnumeratorHandler.java index 457715511589..1cdfb9a3e9f6 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/GradleOrderEnumeratorHandler.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/execution/GradleOrderEnumeratorHandler.java @@ -21,6 +21,7 @@ import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager; import com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceType; import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil; import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.ModuleRootModel; import com.intellij.openapi.roots.OrderEnumerationHandler; import com.intellij.openapi.roots.OrderRootType; @@ -32,10 +33,8 @@ import org.jetbrains.plugins.gradle.model.ExternalProject; import org.jetbrains.plugins.gradle.model.ExternalSourceDirectorySet; import org.jetbrains.plugins.gradle.model.ExternalSourceSet; import org.jetbrains.plugins.gradle.service.project.data.ExternalProjectDataCache; -import org.jetbrains.plugins.gradle.settings.GradleLocalSettings; -import org.jetbrains.plugins.gradle.settings.GradleProjectSettings; -import org.jetbrains.plugins.gradle.settings.GradleSettings; -import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings; +import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService; +import org.jetbrains.plugins.gradle.settings.*; import org.jetbrains.plugins.gradle.util.GradleConstants; import java.io.File; @@ -111,7 +110,8 @@ public class GradleOrderEnumeratorHandler extends OrderEnumerationHandler { return false; } - final ExternalProjectDataCache externalProjectDataCache = ExternalProjectDataCache.getInstance(rootModel.getModule().getProject()); + Project project = rootModel.getModule().getProject(); + final ExternalProjectDataCache externalProjectDataCache = ExternalProjectDataCache.getInstance(project); assert externalProjectDataCache != null; final ExternalProject externalRootProject = externalProjectDataCache.getRootExternalProject(GradleConstants.SYSTEM_ID, new File(gradleProjectPath)); @@ -124,7 +124,7 @@ public class GradleOrderEnumeratorHandler extends OrderEnumerationHandler { externalProjectDataCache.findExternalProject(externalRootProject, rootModel.getModule()); if (externalSourceSets.isEmpty()) return false; - boolean isDelegatedBuildEnabled = GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabled(rootModel.getModule()); + boolean isDelegatedBuildEnabled = GradleSettingsService.getInstance(project).isDelegatedBuildEnabled(rootModel.getModule()); for (ExternalSourceSet sourceSet : externalSourceSets.values()) { if (includeTests) { if (isDelegatedBuildEnabled) { diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/project/GradleExternalSettingsImporter.kt b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/project/GradleExternalSettingsImporter.kt index 80fef02e5999..d98beeb95ff6 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/project/GradleExternalSettingsImporter.kt +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/project/GradleExternalSettingsImporter.kt @@ -16,8 +16,8 @@ import com.intellij.openapi.project.Project import com.intellij.util.ObjectUtils.consumeIfCast import com.intellij.util.ThreeState import org.jetbrains.plugins.gradle.execution.GradleBeforeRunTaskProvider +import org.jetbrains.plugins.gradle.settings.TestRunner.* import org.jetbrains.plugins.gradle.settings.GradleSettings -import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings import org.jetbrains.plugins.gradle.util.GradleConstants class GradleBeforeRunTaskImporter: BeforeRunTaskImporter { @@ -104,9 +104,9 @@ class ActionDelegateConfigImporter: ConfigurationHandler { companion object { private val TEST_RUNNER_MAP = mapOf( - "PLATFORM" to GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER, - "GRADLE" to GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER, - "CHOOSE_PER_TEST" to GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST + "PLATFORM" to PLATFORM, + "GRADLE" to GRADLE, + "CHOOSE_PER_TEST" to CHOOSE_PER_TEST ) } } \ No newline at end of file diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/GradleSettingsService.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/GradleSettingsService.java new file mode 100644 index 000000000000..124ce36af7e3 --- /dev/null +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/GradleSettingsService.java @@ -0,0 +1,67 @@ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package org.jetbrains.plugins.gradle.service.settings; + +import com.intellij.openapi.components.ServiceManager; +import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; +import com.intellij.util.ThreeState; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.plugins.gradle.settings.DefaultGradleProjectSettings; +import org.jetbrains.plugins.gradle.settings.GradleProjectSettings; +import org.jetbrains.plugins.gradle.settings.GradleSettings; +import org.jetbrains.plugins.gradle.settings.TestRunner; + +/** + * {@link GradleSettingsService} provides effective settings for linked gradle projects. + * + * @see GradleProjectSettings + * @see DefaultGradleProjectSettings + * + * @author Vladislav.Soroka + */ +public class GradleSettingsService { + @NotNull + private final Project myProject; + + public GradleSettingsService(@NotNull Project project) { + myProject = project; + } + + public boolean isDelegatedBuildEnabled(@NotNull String gradleProjectPath) { + GradleProjectSettings projectSettings = GradleSettings.getInstance(myProject).getLinkedProjectSettings(gradleProjectPath); + if (projectSettings == null) return false; + if (projectSettings.getDelegatedBuild() == ThreeState.UNSURE) { + return DefaultGradleProjectSettings.getInstance(myProject).isDelegatedBuild(); + } + return projectSettings.getDelegatedBuild().toBoolean(); + } + + @NotNull + public TestRunner getTestRunner(@NotNull String gradleProjectPath) { + GradleProjectSettings projectSettings = GradleSettings.getInstance(myProject).getLinkedProjectSettings(gradleProjectPath); + return projectSettings == null || projectSettings.getTestRunner() == null + ? DefaultGradleProjectSettings.getInstance(myProject).getTestRunner() + : projectSettings.getTestRunner(); + } + + public static boolean isDelegatedBuildEnabled(@NotNull Module module) { + String projectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module); + if (projectPath == null) return false; + return getInstance(module.getProject()).isDelegatedBuildEnabled(projectPath); + } + + @NotNull + public static TestRunner getTestRunner(@NotNull Module module) { + String projectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module); + if (projectPath == null) { + return DefaultGradleProjectSettings.getInstance(module.getProject()).getTestRunner(); + } + return getInstance(module.getProject()).getTestRunner(projectPath); + } + + @NotNull + public static GradleSettingsService getInstance(@NotNull Project project) { + return ServiceManager.getService(project, GradleSettingsService.class); + } +} diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/IdeaGradleProjectSettingsControlBuilder.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/IdeaGradleProjectSettingsControlBuilder.java index 517eb999c2b8..3af24f8e36e3 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/IdeaGradleProjectSettingsControlBuilder.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/settings/IdeaGradleProjectSettingsControlBuilder.java @@ -2,6 +2,7 @@ package org.jetbrains.plugins.gradle.service.settings; import com.intellij.ide.util.projectWizard.WizardContext; +import com.intellij.openapi.Disposable; import com.intellij.openapi.actionSystem.CustomShortcutSet; import com.intellij.openapi.application.ApplicationBundle; import com.intellij.openapi.application.ApplicationManager; @@ -21,6 +22,8 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.roots.ui.configuration.projectRoot.ProjectSdksModel; import com.intellij.openapi.roots.ui.util.CompositeAppearance; import com.intellij.openapi.ui.*; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.registry.Registry; @@ -41,9 +44,10 @@ import org.gradle.util.GradleVersion; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.plugins.gradle.service.GradleInstallationManager; +import org.jetbrains.plugins.gradle.settings.DefaultGradleProjectSettings; import org.jetbrains.plugins.gradle.settings.DistributionType; import org.jetbrains.plugins.gradle.settings.GradleProjectSettings; -import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings; +import org.jetbrains.plugins.gradle.settings.TestRunner; import org.jetbrains.plugins.gradle.util.GradleBundle; import org.jetbrains.plugins.gradle.util.GradleConstants; import org.jetbrains.plugins.gradle.util.GradleUtil; @@ -146,6 +150,16 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet @Nullable private JPanel myGradleJdkPanel; + /** + * The target {@link Project} reference of the UI control. + * It can be the current project of the settings UI configurable (see {@org.jetbrains.plugins.gradle.service.settings.GradleConfigurable}), + * or the target project from the wizard context. + */ + @NotNull + private final Ref myProjectRef = Ref.create(); + @NotNull + private final Disposable myProjectRefDisposable = () -> myProjectRef.set(null); + public IdeaGradleProjectSettingsControlBuilder(@NotNull GradleProjectSettings initialSettings) { myInstallationManager = ServiceManager.getService(GradleInstallationManager.class); myInitialSettings = initialSettings; @@ -561,6 +575,8 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet GradleProjectSettings settings, boolean isDefaultModuleCreation, @Nullable WizardContext wizardContext) { + updateProjectRef(project, wizardContext); + String gradleHome = settings.getGradleHome(); if (myGradleHomePathField != null) { myGradleHomePathField.setText(gradleHome == null ? "" : gradleHome); @@ -764,20 +780,20 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet BuildRunItem[] states = StreamEx.of(ThreeState.values()).map(BuildRunItem::new).toArray(BuildRunItem[]::new); myDelegateBuildCombobox = new ComboBox<>(states); myDelegateBuildCombobox.setRenderer(new MyItemCellRenderer<>()); - myDelegateBuildCombobox.setSelectedItem(BuildRunItem.from(myInitialSettings.getDelegatedBuild())); + myDelegateBuildCombobox.setSelectedItem(new BuildRunItem(myInitialSettings.getDelegatedBuild())); myDelegateBuildLabel = new JBLabel(GradleBundle.message("gradle.settings.text.delegate.buildRun")); myDelegatePanel.add(myDelegateBuildLabel, getLabelConstraints(labelLevel)); myDelegatePanel.add(myDelegateBuildCombobox); } if (!dropTestRunnerCombobox) { - TestRunnerItem[] testRunners = StreamEx.of(GradleSystemRunningSettings.PreferredTestRunner.values()) - .append((GradleSystemRunningSettings.PreferredTestRunner)null) + TestRunnerItem[] testRunners = StreamEx.of(TestRunner.values()) + .append((TestRunner)null) .map(TestRunnerItem::new) .toArray(TestRunnerItem[]::new); myTestRunnerCombobox = new ComboBox<>(testRunners); myTestRunnerCombobox.setRenderer(new MyItemCellRenderer<>()); - myTestRunnerCombobox.setSelectedItem(TestRunnerItem.from(myInitialSettings.getTestRunner())); + myTestRunnerCombobox.setSelectedItem(new TestRunnerItem(myInitialSettings.getTestRunner())); myTestRunnerLabel = new JBLabel(GradleBundle.message("gradle.settings.text.delegate.testRunner")); myDelegatePanel.add(myTestRunnerLabel, getLabelConstraints(labelLevel)); @@ -802,10 +818,10 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet return; } if (myDelegateBuildCombobox != null) { - myDelegateBuildCombobox.setSelectedItem(BuildRunItem.from(myInitialSettings.getDelegatedBuild())); + myDelegateBuildCombobox.setSelectedItem(new BuildRunItem(myInitialSettings.getDelegatedBuild())); } if (myTestRunnerCombobox != null) { - myTestRunnerCombobox.setSelectedItem(TestRunnerItem.from(myInitialSettings.getTestRunner())); + myTestRunnerCombobox.setSelectedItem(new TestRunnerItem(myInitialSettings.getTestRunner())); } } @@ -836,6 +852,17 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet } } + private void updateProjectRef(@Nullable Project project, @Nullable WizardContext wizardContext) { + if (wizardContext != null && wizardContext.getProject() != null) { + project = wizardContext.getProject(); + } + if (project != null && project != myProjectRef.get() + && Disposer.findRegisteredObject(project, myProjectRefDisposable) == null) { + Disposer.register(project, myProjectRefDisposable); + } + myProjectRef.set(project); + } + private class DelayedBalloonInfo implements Runnable { private final MessageType myMessageType; private final String myText; @@ -922,7 +949,7 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet } } - private static class BuildRunItem extends MyItem { + private class BuildRunItem extends MyItem { private BuildRunItem(@Nullable ThreeState value) { super(value); @@ -936,28 +963,27 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet @Override protected String getComment() { if (value != ThreeState.UNSURE) return null; - return getText(ThreeState.fromBoolean(GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabledByDefault())); - } - - private static BuildRunItem from(ThreeState value) { - return new BuildRunItem(value); + ThreeState defaultDelegationOption = + myProjectRef.isNull() ? null : + ThreeState.fromBoolean(DefaultGradleProjectSettings.getInstance(myProjectRef.get()).isDelegatedBuild()); + return getText(defaultDelegationOption); } @NotNull - private static String getText(@Nullable ThreeState state) { + private String getText(@Nullable ThreeState state) { if (state == ThreeState.NO) { return ApplicationNamesInfo.getInstance().getFullProductName(); } if (state == ThreeState.YES) { return "Gradle"; } - return GradleBundle.message("gradle.settings.text.use.application.default"); + return GradleBundle.message("gradle.settings.text.use.default"); } } - private static class TestRunnerItem extends MyItem { + private class TestRunnerItem extends MyItem { - private TestRunnerItem(@Nullable GradleSystemRunningSettings.PreferredTestRunner value) { + private TestRunnerItem(@Nullable TestRunner value) { super(value); } @@ -968,25 +994,24 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet @Override protected String getComment() { - return value != null ? null : getText(GradleSystemRunningSettings.getInstance().getDefaultTestRunner()); - } - - private static TestRunnerItem from(GradleSystemRunningSettings.PreferredTestRunner value) { - return new TestRunnerItem(value); + if (value != null && !myProjectRef.isNull()) return null; + TestRunner defaultRunner = + myProjectRef.isNull() ? null : DefaultGradleProjectSettings.getInstance(myProjectRef.get()).getTestRunner(); + return getText(defaultRunner); } @NotNull - private static String getText(@Nullable GradleSystemRunningSettings.PreferredTestRunner runner) { - if (runner == GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER) { + private String getText(@Nullable TestRunner runner) { + if (runner == TestRunner.PLATFORM) { return ApplicationNamesInfo.getInstance().getFullProductName(); } - if (runner == GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER) { + if (runner == TestRunner.GRADLE) { return "Gradle"; } - if (runner == GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST) { + if (runner == TestRunner.CHOOSE_PER_TEST) { return GradleBundle.message("gradle.preferred_test_runner.CHOOSE_PER_TEST"); } - return GradleBundle.message("gradle.settings.text.use.application.default"); + return GradleBundle.message("gradle.settings.text.use.default"); } } } diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/DefaultGradleProjectSettings.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/DefaultGradleProjectSettings.java new file mode 100644 index 000000000000..0214d6fe3dbf --- /dev/null +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/DefaultGradleProjectSettings.java @@ -0,0 +1,100 @@ +// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package org.jetbrains.plugins.gradle.settings; + +import com.intellij.openapi.components.*; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService; + +/** + * {@link DefaultGradleProjectSettings} holds IDE project level settings defaults for gradle projects. + * + * @see GradleSettingsService + * + * @author Vladislav.Soroka + */ +@State(name = "DefaultGradleProjectSettings", storages = @Storage(StoragePathMacros.WORKSPACE_FILE)) +public class DefaultGradleProjectSettings implements PersistentStateComponent { + private boolean myMigrated; + private boolean myDelegatedBuild; + @NotNull private TestRunner myTestRunner = TestRunner.PLATFORM; + + @NotNull + public TestRunner getTestRunner() { + return myTestRunner; + } + + void setTestRunner(@NotNull TestRunner testRunner) { + myTestRunner = testRunner; + } + + public boolean isDelegatedBuild() { + return myDelegatedBuild; + } + + public void setDelegatedBuild(boolean delegatedBuild) { + myDelegatedBuild = delegatedBuild; + } + + @ApiStatus.ScheduledForRemoval(inVersion = "2019.2") + boolean isMigrated() { + return myMigrated; + } + + @ApiStatus.ScheduledForRemoval(inVersion = "2019.2") + void setMigrated(boolean migrated) { + myMigrated = migrated; + } + + @Nullable + @Override + public DefaultGradleProjectSettings.MyState getState() { + MyState state = new MyState(); + state.delegatedBuild = myDelegatedBuild; + state.testRunner = myTestRunner; + state.isMigrated = myMigrated; + return state; + } + + @Override + public void loadState(@NotNull MyState state) { + if (!state.isMigrated) { + migrateOldSettings(); + } + else { + myDelegatedBuild = state.delegatedBuild; + myTestRunner = state.testRunner; + } + myMigrated = true; + } + + @SuppressWarnings("deprecation") + private void migrateOldSettings() { + GradleSystemRunningSettings oldAppSettings = GradleSystemRunningSettings.getInstance(); + myDelegatedBuild = oldAppSettings.isDelegatedBuildEnabledByDefault(); + GradleSystemRunningSettings.PreferredTestRunner oldTestRunner = oldAppSettings.getDefaultTestRunner(); + if (oldTestRunner == GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER) { + myTestRunner = TestRunner.PLATFORM; + } + else if (oldTestRunner == GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER) { + myTestRunner = TestRunner.GRADLE; + } + else if (oldTestRunner == GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST) { + myTestRunner = TestRunner.CHOOSE_PER_TEST; + } + } + + @NotNull + public static DefaultGradleProjectSettings getInstance(@NotNull Project project) { + return ServiceManager.getService(project, DefaultGradleProjectSettings.class); + } + + static class MyState { + public TestRunner testRunner = TestRunner.PLATFORM; + public boolean delegatedBuild; + @ApiStatus.ScheduledForRemoval(inVersion = "2019.2") + public boolean isMigrated; + } +} \ No newline at end of file diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleProjectSettings.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleProjectSettings.java index 719de0d3963d..ba3b3e590157 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleProjectSettings.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleProjectSettings.java @@ -4,6 +4,7 @@ package org.jetbrains.plugins.gradle.settings; import com.intellij.openapi.externalSystem.service.execution.ExternalSystemJdkUtil; import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings; import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil; +import com.intellij.openapi.module.Module; import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.SmartList; import com.intellij.util.ThreeState; @@ -15,11 +16,19 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.plugins.gradle.model.data.BuildParticipant; import org.jetbrains.plugins.gradle.service.GradleInstallationManager; +import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService; import java.util.List; import java.util.Optional; /** + * {@link GradleProjectSettings} holds settings for the linked gradle project. + * These settings might have IDE project level defaults - {@link DefaultGradleProjectSettings}. + * Consider to use effective settings with {@link GradleSettingsService}. + * + * @see GradleSettingsService + * @see DefaultGradleProjectSettings + * * @author Denis Zhdanov */ public class GradleProjectSettings extends ExternalProjectSettings { @@ -36,7 +45,7 @@ public class GradleProjectSettings extends ExternalProjectSettings { @NotNull private ThreeState delegatedBuild = ThreeState.UNSURE; @Nullable - private GradleSystemRunningSettings.PreferredTestRunner testRunner; + private TestRunner testRunner; @Nullable public String getGradleHome() { @@ -123,17 +132,10 @@ public class GradleProjectSettings extends ExternalProjectSettings { storeProjectFilesExternally = value; } - @Transient - @NotNull - public ThreeState getEffectiveDelegatedBuild() { - if (delegatedBuild == ThreeState.UNSURE) { - return ThreeState.fromBoolean(GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabledByDefault()); - } - return delegatedBuild; - } - /** - * @return {@link ThreeState#UNSURE} means using application level configuration, see {@link GradleSystemRunningSettings#isDelegatedBuildEnabledByDefault()} + * Build/run mode for the gradle project. + * Consider to use effective settings using {@link GradleSettingsService#isDelegatedBuildEnabled(Module)} + * @return build/run mode, {@link ThreeState#UNSURE} means using IDE project level configuration, see {@link DefaultGradleProjectSettings#isDelegatedBuild()} */ @OptionTag(value = "delegatedBuild", converter = ThreeStateConverter.class) @NotNull @@ -142,33 +144,26 @@ public class GradleProjectSettings extends ExternalProjectSettings { } /** - * @param state {@link ThreeState#UNSURE} means using application level configuration, see {@link GradleSystemRunningSettings#isDelegatedBuildEnabledByDefault()} + * @param state {@link ThreeState#UNSURE} means using IDE project level configuration, see {@link DefaultGradleProjectSettings#isDelegatedBuild()} */ public void setDelegatedBuild(@NotNull ThreeState state) { this.delegatedBuild = state; } - @Transient - @NotNull - public GradleSystemRunningSettings.PreferredTestRunner getEffectiveTestRunner() { - if (testRunner == null) { - return GradleSystemRunningSettings.getInstance().getDefaultTestRunner(); - } - return testRunner; - } - /** - * @return test runner option, "null" means using application level configuration, see {@link GradleSystemRunningSettings#getDefaultTestRunner()} + * Test runner option. + * Consider to use effective settings using {@link GradleSettingsService#getTestRunner(Module)} + * @return test runner option, "null" means using IDE project level configuration, see {@link DefaultGradleProjectSettings#getTestRunner()} */ @Nullable - public GradleSystemRunningSettings.PreferredTestRunner getTestRunner() { + public TestRunner getTestRunner() { return testRunner; } /** - * @param testRunner null means using application level configuration, see {@link GradleSystemRunningSettings#getDefaultTestRunner()} + * @param testRunner null means using IDE project level configuration, see {@link DefaultGradleProjectSettings#getTestRunner()} */ - public void setTestRunner(@Nullable GradleSystemRunningSettings.PreferredTestRunner testRunner) { + public void setTestRunner(@Nullable TestRunner testRunner) { this.testRunner = testRunner; } diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleRunnerConfigurable.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleRunnerConfigurable.java index 1bae59a8e240..337e2333ca42 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleRunnerConfigurable.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleRunnerConfigurable.java @@ -6,6 +6,7 @@ import com.intellij.openapi.options.ConfigurationException; import com.intellij.openapi.ui.ComboBox; import com.intellij.ui.components.JBCheckBox; import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.plugins.gradle.util.GradleBundle; @@ -20,9 +21,14 @@ public class GradleRunnerConfigurable implements Configurable { private JBCheckBox myGradleAwareMakeCheckBox; private ComboBox myPreferredTestRunner; private static final TestRunnerItem[] TEST_RUNNER_ITEMS = new TestRunnerItem[]{ - new TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER), - new TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER), - new TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST)}; + new TestRunnerItem(TestRunner.PLATFORM), + new TestRunnerItem(TestRunner.GRADLE), + new TestRunnerItem(TestRunner.CHOOSE_PER_TEST)}; + private final DefaultGradleProjectSettings mySettings; + + public GradleRunnerConfigurable(@NotNull DefaultGradleProjectSettings settings) { + mySettings = settings; + } @Nls @Override @@ -39,18 +45,16 @@ public class GradleRunnerConfigurable implements Configurable { @Override public void apply() throws ConfigurationException { boolean gradleMakeEnabled = myGradleAwareMakeCheckBox.isSelected(); - GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance(); - settings.setDelegatedBuildEnabledByDefault(gradleMakeEnabled); - GradleSystemRunningSettings.PreferredTestRunner preferredTestRunner = getSelectedRunner(); - settings.setDefaultTestRunner(preferredTestRunner); + mySettings.setDelegatedBuild(gradleMakeEnabled); + TestRunner preferredTestRunner = getSelectedRunner(); + mySettings.setTestRunner(preferredTestRunner); } @Override public void reset() { - GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance(); - final TestRunnerItem item = getItem(settings.getDefaultTestRunner()); + TestRunnerItem item = getItem(mySettings.getTestRunner()); myPreferredTestRunner.setSelectedItem(item); - boolean gradleMakeEnabled = settings.isDelegatedBuildEnabledByDefault(); + boolean gradleMakeEnabled = mySettings.isDelegatedBuild(); enableGradleMake(gradleMakeEnabled); } @@ -62,12 +66,8 @@ public class GradleRunnerConfigurable implements Configurable { @Override public boolean isModified() { - GradleSystemRunningSettings uiSettings = new GradleSystemRunningSettings(); - GradleSystemRunningSettings.PreferredTestRunner preferredTestRunner = getSelectedRunner(); - uiSettings.setDefaultTestRunner(preferredTestRunner); - uiSettings.setDelegatedBuildEnabledByDefault(myGradleAwareMakeCheckBox.isSelected()); - GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance(); - return !settings.equals(uiSettings); + return mySettings.isDelegatedBuild() != myGradleAwareMakeCheckBox.isSelected() || + mySettings.getTestRunner() != getSelectedRunner(); } private void createUIComponents() { @@ -80,12 +80,12 @@ public class GradleRunnerConfigurable implements Configurable { myGradleAwareMakeCheckBox.setSelected(enable); } - private GradleSystemRunningSettings.PreferredTestRunner getSelectedRunner() { + private TestRunner getSelectedRunner() { final TestRunnerItem selectedItem = (TestRunnerItem)myPreferredTestRunner.getSelectedItem(); - return selectedItem == null ? GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST : selectedItem.value; + return selectedItem == null ? TestRunner.CHOOSE_PER_TEST : selectedItem.value; } - private static TestRunnerItem getItem(GradleSystemRunningSettings.PreferredTestRunner preferredTestRunner) { + private static TestRunnerItem getItem(TestRunner preferredTestRunner) { for (TestRunnerItem item : getItems()) { if (item.value == preferredTestRunner) return item; } @@ -97,12 +97,12 @@ public class GradleRunnerConfigurable implements Configurable { } static class TestRunnerItem { - TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner value) { + TestRunner value; + + TestRunnerItem(TestRunner value) { this.value = value; } - GradleSystemRunningSettings.PreferredTestRunner value; - @Override public boolean equals(Object o) { if (this == o) return true; diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleSystemRunningSettings.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleSystemRunningSettings.java index 1a27156e46ed..c2cfd90ac456 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleSystemRunningSettings.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/settings/GradleSystemRunningSettings.java @@ -5,19 +5,21 @@ import com.intellij.openapi.components.PersistentStateComponent; import com.intellij.openapi.components.ServiceManager; import com.intellij.openapi.components.State; import com.intellij.openapi.components.Storage; -import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.project.Project; import com.intellij.util.xmlb.annotations.OptionTag; import org.gradle.internal.impldep.com.google.common.base.Objects; import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService; /** * @author Vladislav.Soroka + * + * @deprecated use {@link GradleSettingsService} */ -@State(name = "GradleSystemRunningSettings", storages = @Storage("gradle.run.settings.xml")) +@Deprecated +@ApiStatus.ScheduledForRemoval(inVersion = "2019.2") +@State(name = "GradleSystemRunningSettings", storages = @Storage(value = "gradle.run.settings.xml", deprecated = true)) public class GradleSystemRunningSettings implements PersistentStateComponent { private boolean myDelegatedBuildEnabledByDefault; @NotNull private PreferredTestRunner myPreferredTestRunner = PreferredTestRunner.PLATFORM_TEST_RUNNER; @@ -42,54 +44,12 @@ public class GradleSystemRunningSettings implements PersistentStateComponent