1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/*******************************************************************************
* Copyright (c) 2000, 2013 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.externaltools.internal.model;
import java.util.Map;
import org.eclipse.core.externaltools.internal.model.BuilderCoreUtils;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
/**
* Utility methods for working with external tool project builders.
*/
public class BuilderUtils {
// Extension point constants.
private static final String TAG_CONFIGURATION_MAP = "configurationMap"; //$NON-NLS-1$
private static final String TAG_SOURCE_TYPE = "sourceType"; //$NON-NLS-1$
private static final String TAG_BUILDER_TYPE = "builderType"; //$NON-NLS-1$
/**
* Returns a launch configuration from the given ICommand arguments. If the
* given arguments are from an old-style external tool, an unsaved working
* copy will be created from the arguments and returned.
*
* @param commandArgs the builder ICommand arguments
* @return a launch configuration, a launch configuration working copy, or
* <code>null</code> if not possible.
*/
public static ILaunchConfiguration configFromBuildCommandArgs(IProject project, Map<String, String> commandArgs, String[] version) {
return BuilderCoreUtils.configFromBuildCommandArgs(project, commandArgs, version);
}
/**
* Returns an <code>ICommand</code> from the given launch configuration.
*
* @param project the project the ICommand is relevant to
* @param config the launch configuration to create the command from
* @return the new command. <code>null</code> can be returned if problems occur during
* the translation.
*/
public static ICommand commandFromLaunchConfig(IProject project, ILaunchConfiguration config) {
ICommand newCommand = null;
try {
newCommand = project.getDescription().newCommand();
newCommand = toBuildCommand(project, config, newCommand);
configureTriggers(config, newCommand);
} catch (CoreException exception) {
Shell shell= ExternalToolsPlugin.getActiveWorkbenchShell();
if (shell != null) {
MessageDialog.openError(shell, ExternalToolsModelMessages.BuilderUtils_5, ExternalToolsModelMessages.BuilderUtils_6);
}
return null;
}
return newCommand;
}
public static void configureTriggers(ILaunchConfiguration config, ICommand newCommand) throws CoreException {
BuilderCoreUtils.configureTriggers(config, newCommand);
}
/**
* Returns whether the given configuration is an "unmigrated" builder.
* Unmigrated builders are external tools that are stored in an old format
* but have not been migrated by the user. Old format builders are always
* translated into launch config working copies in memory, but they're not
* considered "migrated" until the config has been saved and the project spec
* updated.
* @param config the config to examine
* @return whether the given config represents an unmigrated builder
*/
public static boolean isUnmigratedConfig(ILaunchConfiguration config) {
return BuilderCoreUtils.isUnmigratedConfig(config);
}
/**
* Converts the given config to a build command which is stored in the
* given command.
*
* @return the configured build command
*/
public static ICommand toBuildCommand(IProject project, ILaunchConfiguration config, ICommand command) throws CoreException {
return BuilderCoreUtils.toBuildCommand(project, config, command);
}
/**
* Returns the type of launch configuration that should be created when
* duplicating the given configuration as a project builder. Queries to see
* if an extension has been specified to explicitly declare the mapping.
*/
public static ILaunchConfigurationType getConfigurationDuplicationType(ILaunchConfiguration config) throws CoreException {
IExtensionPoint ep= Platform.getExtensionRegistry().getExtensionPoint(ExternalToolsPlugin.PLUGIN_ID, IExternalToolConstants.EXTENSION_POINT_CONFIGURATION_DUPLICATION_MAPS);
IConfigurationElement[] elements = ep.getConfigurationElements();
String sourceType= config.getType().getIdentifier();
String builderType= null;
for (IConfigurationElement element : elements) {
if (element.getName().equals(TAG_CONFIGURATION_MAP) && sourceType.equals(element.getAttribute(TAG_SOURCE_TYPE))) {
builderType= element.getAttribute(TAG_BUILDER_TYPE);
break;
}
}
if (builderType != null) {
ILaunchConfigurationType type= DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(builderType);
if (type != null) {
return type;
}
}
return config.getType();
}
/**
* Returns the folder where project builders should be stored or
* <code>null</code> if the folder could not be created
*/
public static IFolder getBuilderFolder(IProject project, boolean create) {
return BuilderCoreUtils.getBuilderFolder(project, create);
}
/**
* Returns a duplicate of the given configuration. The new configuration
* will be of the same type as the given configuration or of the duplication
* type registered for the given configuration via the extension point
* IExternalToolConstants.EXTENSION_POINT_CONFIGURATION_DUPLICATION_MAPS.
*/
public static ILaunchConfiguration duplicateConfiguration(IProject project, ILaunchConfiguration config) throws CoreException {
Map<String, Object> attributes = config.getAttributes();
String newName= new StringBuilder(config.getName()).append(ExternalToolsModelMessages.BuilderUtils_7).toString();
newName= DebugPlugin.getDefault().getLaunchManager().generateLaunchConfigurationName(newName);
ILaunchConfigurationType newType= getConfigurationDuplicationType(config);
ILaunchConfigurationWorkingCopy newWorkingCopy= newType.newInstance(getBuilderFolder(project, true), newName);
newWorkingCopy.setAttributes(attributes);
return newWorkingCopy.doSave();
}
/**
* Migrates the launch configuration working copy, which is based on an old-
* style external tool builder, to a new, saved launch configuration. The
* returned launch configuration will contain the same attributes as the
* given working copy with the exception of the configuration name, which
* may be changed during the migration. The name of the configuration will
* only be changed if the current name is not a valid name for a saved
* config.
*
* @param workingCopy the launch configuration containing attributes from an
* old-style project builder.
* @return ILaunchConfiguration a new, saved launch configuration whose
* attributes match those of the given working copy as well as possible
* @throws CoreException if an exception occurs while attempting to save the
* new launch configuration
*/
public static ILaunchConfiguration migrateBuilderConfiguration(IProject project, ILaunchConfigurationWorkingCopy workingCopy) throws CoreException {
return BuilderCoreUtils.migrateBuilderConfiguration(project, workingCopy);
}
/**
* Converts the build types string into an array of
* build kinds.
*
* @param buildTypes the string of built types to convert
* @return the array of build kinds.
*/
public static int[] buildTypesToArray(String buildTypes) {
return BuilderCoreUtils.buildTypesToArray(buildTypes);
}
}
|
