import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
* @see ExecutionManager
*/
public abstract class RunManager {
+ public static final String UNNAMED = "Unnamed";
+
public static RunManager getInstance(final Project project) {
return project.getComponent(RunManager.class);
}
i++;
}
}
+
+ public String suggestUniqueName(@Nullable String name, @Nullable ConfigurationType type) {
+ List<RunnerAndConfigurationSettings> settingsList = type != null ? getConfigurationSettingsList(type) : getAllSettings();
+ List<String> names = ContainerUtil.map(settingsList, new Function<RunnerAndConfigurationSettings, String>() {
+ @Override
+ public String fun(RunnerAndConfigurationSettings settings) {
+ return settings.getName();
+ }
+ });
+ return suggestUniqueName(StringUtil.notNullize(name, UNNAMED), names);
+ }
+
+ /**
+ * Sets unique name if existing one is not 'unique'
+ * If settings type is not null (for example settings may be provided by plugin that is unavailable after IDE restart, so type would be suddenly null)
+ * name will be chosen unique for certain type otherwise name will be unique among all configurations
+ * @return <code>true</code> if name was changed
+ */
+ public boolean setUniqueNameIfNeed(@NotNull RunnerAndConfigurationSettings settings) {
+ String oldName = settings.getName();
+ settings.setName(suggestUniqueName(StringUtil.notNullize(oldName, UNNAMED), settings.getType()));
+ return !Comparing.equal(oldName, settings.getName());
+ }
+
+ /**
+ * Sets unique name if existing one is not 'unique' for corresponding configuration type
+ * @return <code>true</code> if name was changed
+ */
+ public boolean setUniqueNameIfNeed(@NotNull RunConfiguration configuration) {
+ String oldName = configuration.getName();
+ configuration.setName(suggestUniqueName(StringUtil.notNullize(oldName, UNNAMED), configuration.getType()));
+ return !Comparing.equal(oldName, configuration.getName());
+ }
}
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import java.util.*;
+import java.util.List;
/**
* Supports creating run configurations from context (by right-clicking a code element in the source editor or the project view). Typically,
// replace with existing configuration if any
final RunManager runManager = RunManager.getInstance(context.getProject());
final ConfigurationType type = fromContext.getConfigurationType();
- final List<RunnerAndConfigurationSettings> configurations = runManager.getConfigurationSettingsList(type);
final RunnerAndConfigurationSettings settings = findExistingConfiguration(context);
if (settings != null) {
fromContext.setConfigurationSettings(settings);
} else {
- final ArrayList<String> currentNames = new ArrayList<String>();
- for (RunnerAndConfigurationSettings configurationSettings : configurations) {
- currentNames.add(configurationSettings.getName());
- }
- RunConfiguration configuration = fromContext.getConfiguration();
- String name = configuration.getName();
- if (name == null) {
- LOG.error(configuration);
- name = "Unnamed";
- }
- configuration.setName(RunManager.suggestUniqueName(name, currentNames));
+ runManager.setUniqueNameIfNeed(fromContext.getConfiguration());
}
}
}
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
if (result.myConfiguration != null) {
final PsiElement psiElement = result.getSourceElement();
- final Location<PsiElement> _location = PsiLocation.fromPsiElement(psiElement, location != null ? location.getModule() : null);
+ final Location<PsiElement> _location = PsiLocation.fromPsiElement(psiElement, location.getModule());
if (_location != null) {
// replace with existing configuration if any
final RunManager runManager = RunManager.getInstance(context.getProject());
final ConfigurationType type = result.myConfiguration.getType();
- final List<RunnerAndConfigurationSettings> configurations = runManager.getConfigurationSettingsList(type);
- final RunnerAndConfigurationSettings configuration = result.findExistingByElement(_location, configurations, context);
+ RunnerAndConfigurationSettings configuration = null;
+ if (type != null) {
+ configuration = result.findExistingByElement(_location, runManager.getConfigurationSettingsList(type), context);
+ }
if (configuration != null) {
result.myConfiguration = configuration;
} else {
- final ArrayList<String> currentNames = new ArrayList<String>();
- for (RunnerAndConfigurationSettings configurationSettings : configurations) {
- currentNames.add(configurationSettings.getName());
- }
- result.myConfiguration.setName(RunManager.suggestUniqueName(result.myConfiguration.getName(), currentNames));
+ runManager.setUniqueNameIfNeed(result.myConfiguration);
}
}
}