refactor "suggestUniqueName"
[idea/community.git] / platform / lang-api / src / com / intellij / execution / RunManager.java
1 /*
2  * Copyright 2000-2014 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.execution;
17
18 import com.intellij.execution.configurations.ConfigurationFactory;
19 import com.intellij.execution.configurations.ConfigurationType;
20 import com.intellij.execution.configurations.RunConfiguration;
21 import com.intellij.execution.configurations.RunProfile;
22 import com.intellij.openapi.project.Project;
23 import com.intellij.openapi.util.Comparing;
24 import com.intellij.openapi.util.text.StringUtil;
25 import com.intellij.util.Function;
26 import com.intellij.util.containers.ContainerUtil;
27 import org.jetbrains.annotations.NotNull;
28 import org.jetbrains.annotations.Nullable;
29
30 import java.util.Collection;
31 import java.util.List;
32 import java.util.regex.Matcher;
33 import java.util.regex.Pattern;
34
35 /**
36  * Manages the list of run/debug configurations in a project.
37  *
38  * @author anna
39  * @see RunnerRegistry
40  * @see ExecutionManager
41  */
42 public abstract class RunManager {
43   public static final String UNNAMED = "Unnamed";
44
45   public static RunManager getInstance(final Project project) {
46     return project.getComponent(RunManager.class);
47   }
48
49   /**
50    * Returns the list of all registered configuration types.
51    *
52    * @return all registered configuration types.
53    */
54   @NotNull
55   public abstract ConfigurationType[] getConfigurationFactories();
56
57   /**
58    * Returns the list of all configurations of a specified type.
59    *
60    * @param type a run configuration type.
61    * @return all configurations of the type, or an empty array if no configurations of the type are defined.
62    */
63   @NotNull
64   @Deprecated
65   public abstract RunConfiguration[] getConfigurations(@NotNull ConfigurationType type);
66
67   /**
68    * Returns the list of all configurations of a specified type.
69    *
70    * @param type a run configuration type.
71    * @return all configurations of the type, or an empty array if no configurations of the type are defined.
72    */
73   @NotNull
74   public abstract List<RunConfiguration> getConfigurationsList(@NotNull ConfigurationType type);
75
76   /**
77    * Returns the list of {@link RunnerAndConfigurationSettings} for all configurations of a specified type.
78    *
79    * @param type a run configuration type.
80    * @return settings for all configurations of the type, or an empty array if no configurations of the type are defined.
81    */
82   @NotNull
83   @Deprecated
84   public abstract RunnerAndConfigurationSettings[] getConfigurationSettings(@NotNull ConfigurationType type);
85
86   /**
87    * Returns the list of {@link RunnerAndConfigurationSettings} for all configurations of a specified type.
88    *
89    * @param type a run configuration type.
90    * @return settings for all configurations of the type, or an empty array if no configurations of the type are defined.
91    */
92   @NotNull
93   public abstract List<RunnerAndConfigurationSettings> getConfigurationSettingsList(@NotNull ConfigurationType type);
94
95   /**
96    * Returns the list of all run configurations.
97    *
98    * @return the list of all run configurations.
99    */
100   @NotNull
101   @Deprecated
102   public abstract RunConfiguration[] getAllConfigurations();
103
104   /**
105    * Returns the list of all run configurations.
106    *
107    * @return the list of all run configurations.
108    */
109   @NotNull
110   public abstract List<RunConfiguration> getAllConfigurationsList();
111
112   /**
113    * Returns the list of all run configurations settings.
114    *
115    * @return the list of all run configurations settings.
116    */
117   @NotNull
118   public abstract List<RunnerAndConfigurationSettings> getAllSettings();
119
120   /**
121    * Returns the list of all temporary run configurations.
122    *
123    * @return the list of all temporary run configurations.
124    * @see RunnerAndConfigurationSettings#isTemporary()
125    */
126   @NotNull
127   @Deprecated
128   public abstract RunConfiguration[] getTempConfigurations();
129
130   /**
131    * Returns the list of all temporary run configurations settings.
132    *
133    * @return the list of all temporary run configurations settings.
134    * @see RunnerAndConfigurationSettings#isTemporary()
135    */
136   @NotNull
137   public abstract List<RunnerAndConfigurationSettings> getTempConfigurationsList();
138
139   /**
140    * Checks if the specified run configuration is temporary and will be deleted when the temporary configurations limit is exceeded.
141    *
142    * @return true if the configuration is temporary, false otherwise.
143    * @see RunnerAndConfigurationSettings#isTemporary()
144    */
145   @Deprecated
146   public abstract boolean isTemporary(@NotNull RunConfiguration configuration);
147
148   /**
149    * Saves the specified temporary run configuration and makes it a permanent one.
150    *
151    * @param configuration the temporary run configuration to save.
152    */
153   @Deprecated
154   public abstract void makeStable(@NotNull RunConfiguration configuration);
155
156   /**
157    * Saves the specified temporary run settings and makes it a permanent one.
158    *
159    * @param settings the temporary settings to save.
160    */
161   public abstract void makeStable(@NotNull RunnerAndConfigurationSettings settings);
162
163   /**
164    * Returns the selected item in the run/debug configurations combobox.
165    *
166    * @return the selected configuration, or null if no configuration is defined or selected.
167    */
168   @Nullable
169   public abstract RunnerAndConfigurationSettings getSelectedConfiguration();
170
171   /**
172    * Selects a configuration in the run/debug configurations combobox.
173    *
174    * @param configuration the configuration to select, or null if nothing should be selected.
175    */
176   public abstract void setSelectedConfiguration(@Nullable RunnerAndConfigurationSettings configuration);
177
178   /**
179    * Creates a configuration of the specified type with the specified name. Note that you need to call
180    * {@link #addConfiguration(RunnerAndConfigurationSettings, boolean)} if you want the configuration to be persisted in the project.
181    *
182    * @param name the name of the configuration to create (should be unique and not equal to any other existing configuration)
183    * @param type the type of the configuration to create.
184    * @return the configuration settings object.
185    * @see RunManager#suggestUniqueName(String, Collection)
186    */
187   @NotNull
188   public abstract RunnerAndConfigurationSettings createRunConfiguration(@NotNull String name, @NotNull ConfigurationFactory type);
189
190   /**
191    * Creates a configuration settings object based on a specified {@link RunConfiguration}. Note that you need to call
192    * {@link #addConfiguration(RunnerAndConfigurationSettings, boolean)} if you want the configuration to be persisted in the project.
193    *
194    * @param runConfiguration the run configuration
195    * @param factory the factory instance.
196    * @return the configuration settings object.
197    */
198   @NotNull
199   public abstract RunnerAndConfigurationSettings createConfiguration(@NotNull RunConfiguration runConfiguration, @NotNull ConfigurationFactory factory);
200
201   /**
202    * Returns the template settings for the specified configuration type.
203    *
204    * @param factory the configuration factory.
205    * @return the template settings.
206    */
207   @NotNull
208   public abstract RunnerAndConfigurationSettings getConfigurationTemplate(ConfigurationFactory factory);
209
210   /**
211    * Adds the specified run configuration to the list of run configurations stored in the project.
212    *
213    * @param settings the run configuration settings.
214    * @param isShared true if the configuration is marked as shared (stored in the versioned part of the project files), false if it's local
215    *                 (stored in the workspace file).
216    */
217   public abstract void addConfiguration(final RunnerAndConfigurationSettings settings, final boolean isShared);
218
219   /**
220    * Marks the specified run configuration as recently used (the temporary run configurations are deleted in LRU order).
221    *
222    * @param profile the run configuration to mark as recently used.
223    */
224   public abstract void refreshUsagesList(RunProfile profile);
225
226   @NotNull
227   public static String suggestUniqueName(@NotNull String str, @NotNull Collection<String> currentNames) {
228     if (!currentNames.contains(str)) return str;
229
230     final Matcher matcher = Pattern.compile("(.*?)\\s*\\(\\d+\\)").matcher(str);
231     final String originalName = (matcher.matches()) ? matcher.group(1) : str;
232     int i = 1;
233     while (true) {
234       final String newName = String.format("%s (%d)", originalName, i);
235       if (!currentNames.contains(newName)) return newName;
236       i++;
237     }
238   }
239
240   public String suggestUniqueName(@Nullable String name, @Nullable ConfigurationType type) {
241     List<RunnerAndConfigurationSettings> settingsList = type != null ? getConfigurationSettingsList(type) : getAllSettings();
242     List<String> names = ContainerUtil.map(settingsList, new Function<RunnerAndConfigurationSettings, String>() {
243       @Override
244       public String fun(RunnerAndConfigurationSettings settings) {
245         return settings.getName();
246       }
247     });
248     return suggestUniqueName(StringUtil.notNullize(name, UNNAMED), names);
249   }
250
251   /**
252    * Sets unique name if existing one is not 'unique'
253    * 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)
254    * name will be chosen unique for certain type otherwise name will be unique among all configurations
255    * @return <code>true</code> if name was changed
256    */
257   public boolean setUniqueNameIfNeed(@NotNull RunnerAndConfigurationSettings settings) {
258     String oldName = settings.getName();
259     settings.setName(suggestUniqueName(StringUtil.notNullize(oldName, UNNAMED), settings.getType()));
260     return !Comparing.equal(oldName, settings.getName());
261   }
262
263   /**
264    * Sets unique name if existing one is not 'unique' for corresponding configuration type
265    * @return <code>true</code> if name was changed
266    */
267   public boolean setUniqueNameIfNeed(@NotNull RunConfiguration configuration) {
268     String oldName = configuration.getName();
269     configuration.setName(suggestUniqueName(StringUtil.notNullize(oldName, UNNAMED), configuration.getType()));
270     return !Comparing.equal(oldName, configuration.getName());
271   }
272 }