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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
/*******************************************************************************
* Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.externaltools.internal.registry;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.ui.externaltools.internal.model.IExternalToolConstants;
import org.eclipse.ui.externaltools.internal.model.ToolUtil;
/**
* Responsible reading an old external tool format and creating
* and migrating it to create a new external tool.
*/
public final class ExternalToolMigration {
/*
* Ant tags
*/
public static final String RUN_TARGETS_ATTRIBUTE = IExternalToolConstants.TOOL_TYPE_ANT_BUILD + ".runTargets"; //$NON-NLS-1$;
/*
* 2.0 External Tool Tags
*/
private static final String TAG_TOOL_TYPE = "!{tool_type}"; //$NON-NLS-1$
private static final String TAG_TOOL_NAME = "!{tool_name}"; //$NON-NLS-1$
private static final String TAG_TOOL_LOCATION = "!{tool_loc}"; //$NON-NLS-1$
private static final String TAG_TOOL_ARGUMENTS = "!{tool_args}"; //$NON-NLS-1$
private static final String TAG_TOOL_DIRECTORY = "!{tool_dir}"; //$NON-NLS-1$
private static final String TAG_TOOL_REFRESH = "!{tool_refresh}"; //$NON-NLS-1$
private static final String TAG_TOOL_SHOW_LOG = "!{tool_show_log}"; //$NON-NLS-1$
private static final String TAG_TOOL_BUILD_TYPES = "!{tool_build_types}"; //$NON-NLS-1$
private static final String TAG_TOOL_BLOCK = "!{tool_block}"; //$NON-NLS-1$
// Known kind of tools
private static final String TOOL_TYPE_ANT = "org.eclipse.ui.externaltools.type.ant"; //$NON-NLS-1$
/*
* 2.1 External Tool Keys
*/
private static final String TAG_TYPE = "type"; //$NON-NLS-1$
private static final String TAG_NAME = "name"; //$NON-NLS-1$
private static final String TAG_LOCATION = "location"; //$NON-NLS-1$
private static final String TAG_WORK_DIR = "workDirectory"; //$NON-NLS-1$
private static final String TAG_CAPTURE_OUTPUT = "captureOutput"; //$NON-NLS-1$
private static final String TAG_SHOW_CONSOLE = "showConsole"; //$NON-NLS-1$
private static final String TAG_RUN_BKGRND = "runInBackground"; //$NON-NLS-1$
private static final String TAG_PROMPT_ARGS = "promptForArguments"; //$NON-NLS-1$
private static final String TAG_ARGS = "arguments"; //$NON-NLS-1$
private static final String TAG_REFRESH_SCOPE = "refreshScope"; //$NON-NLS-1$
private static final String TAG_REFRESH_RECURSIVE = "refreshRecursive"; //$NON-NLS-1$
private static final String TAG_RUN_BUILD_KINDS = "runForBuildKinds"; //$NON-NLS-1$
private static final String TAG_EXTRA_ATTR = "extraAttribute"; //$NON-NLS-1$
private static final String TAG_VERSION = "version"; //$NON-NLS-1$
private static final String EXTRA_ATTR_SEPARATOR = "="; //$NON-NLS-1$
private static final String VERSION_21 = "2.1"; //$NON-NLS-1$;
private static final String TRUE = "true"; //$NON-NLS-1$
private static final String FALSE = "false"; //$NON-NLS-1$
/**
* Allows no instances.
*/
private ExternalToolMigration() {
super();
}
/**
* Returns a launch configuration working copy from the argument map or
* <code>null</code> if the given map cannot be interpreted as a 2.0 or 2.1
* branch external tool. The returned working copy will be unsaved and its
* location will be set to the metadata area.
*/
public static ILaunchConfigurationWorkingCopy configFromArgumentMap(Map args) {
String version = (String) args.get(TAG_VERSION);
if (VERSION_21.equals(version)) {
return configFrom21ArgumentMap(args);
}
return configFrom20ArgumentMap(args);
}
public static ILaunchConfigurationWorkingCopy configFrom21ArgumentMap(Map commandArgs) {
String name = (String) commandArgs.get(TAG_NAME);
String type = (String) commandArgs.get(TAG_TYPE);
ILaunchConfigurationWorkingCopy config = newConfig(type, name);
if (config == null) {
return null;
}
config.setAttribute(IExternalToolConstants.ATTR_LOCATION, (String) commandArgs.get(TAG_LOCATION));
config.setAttribute(IExternalToolConstants.ATTR_WORKING_DIRECTORY, (String) commandArgs.get(TAG_WORK_DIR));
config.setAttribute(IExternalToolConstants.ATTR_CAPTURE_OUTPUT, TRUE.equals((String) commandArgs.get(TAG_CAPTURE_OUTPUT)));
config.setAttribute(IExternalToolConstants.ATTR_SHOW_CONSOLE, TRUE.equals((String) commandArgs.get(TAG_SHOW_CONSOLE)));
config.setAttribute(IExternalToolConstants.ATTR_RUN_IN_BACKGROUND, TRUE.equals((String) commandArgs.get(TAG_RUN_BKGRND)));
config.setAttribute(IExternalToolConstants.ATTR_PROMPT_FOR_ARGUMENTS, TRUE.equals((String) commandArgs.get(TAG_PROMPT_ARGS)));
config.setAttribute(IExternalToolConstants.ATTR_REFRESH_SCOPE, (String) commandArgs.get(TAG_REFRESH_SCOPE));
config.setAttribute(IExternalToolConstants.ATTR_REFRESH_RECURSIVE, TRUE.equals((String) commandArgs.get(TAG_REFRESH_RECURSIVE)));
config.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, (String) commandArgs.get(TAG_RUN_BUILD_KINDS));
String args = (String) commandArgs.get(TAG_ARGS);
if (args != null) {
config.setAttribute(IExternalToolConstants.ATTR_TOOL_ARGUMENTS, args);
}
String extraAttributes = (String) commandArgs.get(TAG_EXTRA_ATTR);
if (extraAttributes != null) {
StringTokenizer tokenizer = new StringTokenizer(extraAttributes, EXTRA_ATTR_SEPARATOR);
while (tokenizer.hasMoreTokens()) {
String key = tokenizer.nextToken();
if (!tokenizer.hasMoreTokens())
break;
String value = tokenizer.nextToken();
if (key.equals(RUN_TARGETS_ATTRIBUTE)) {
// 2.1 implementation only defined 1 "extra attribute"
config.setAttribute(IExternalToolConstants.ATTR_ANT_TARGETS, value);
}
}
}
return config;
}
/**
* Creates an external tool from the map.
*/
public static ILaunchConfigurationWorkingCopy configFrom20ArgumentMap(Map args) {
// Update the type...
String type = (String) args.get(TAG_TOOL_TYPE);
if (TOOL_TYPE_ANT.equals(type))
type = IExternalToolConstants.TOOL_TYPE_ANT_BUILD;
else
type = IExternalToolConstants.TOOL_TYPE_PROGRAM;
String name = (String) args.get(TAG_TOOL_NAME);
ILaunchConfigurationWorkingCopy config = newConfig(type, name);
if (config == null) {
return null;
}
// Update the location...
String location = (String) args.get(TAG_TOOL_LOCATION);
if (location != null) {
ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(location, 0);
if (IExternalToolConstants.VAR_WORKSPACE_LOC.equals(varDef.name)) {
location = ToolUtil.buildVariableTag(IExternalToolConstants.VAR_RESOURCE_LOC, varDef.argument);
}
config.setAttribute(IExternalToolConstants.ATTR_LOCATION, location);
}
// Update the refresh scope...
String refresh = (String) args.get(TAG_TOOL_REFRESH);
if (refresh != null) {
ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(refresh, 0);
if ("none".equals(varDef.name)) { //$NON-NLS-1$
refresh = null;
}
config.setAttribute(IExternalToolConstants.ATTR_REFRESH_SCOPE, refresh);
}
// Update the arguments
String arguments = (String) args.get(TAG_TOOL_ARGUMENTS);
String targetNames = null;
if (arguments != null) {
int start = 0;
ArrayList targets = new ArrayList();
StringBuffer buffer = new StringBuffer();
ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(arguments, start);
while (varDef.end != -1) {
if ("ant_target".equals(varDef.name) && varDef.argument != null) { //$NON-NLS-1$
targets.add(varDef.argument);
buffer.append(arguments.substring(start, varDef.start));
} else {
buffer.append(arguments.substring(start, varDef.end));
}
start = varDef.end;
varDef = ToolUtil.extractVariableTag(arguments, start);
}
buffer.append(arguments.substring(start, arguments.length()));
arguments = buffer.toString();
buffer.setLength(0);
for (int i = 0; i < targets.size(); i++) {
String target = (String) targets.get(i);
if (target != null && target.length() > 0) {
buffer.append(target);
buffer.append(","); //$NON-NLS-1$
}
}
targetNames = buffer.toString();
}
if (targetNames != null && targetNames.length() > 0) {
config.setAttribute(IExternalToolConstants.ATTR_ANT_TARGETS, targetNames);
}
// Collect the rest of the information
config.setAttribute(IExternalToolConstants.ATTR_SHOW_CONSOLE, TRUE.equals((String) args.get(TAG_TOOL_SHOW_LOG)));
config.setAttribute(IExternalToolConstants.ATTR_CAPTURE_OUTPUT, TRUE.equals((String) args.get(TAG_TOOL_SHOW_LOG)));
config.setAttribute(IExternalToolConstants.ATTR_RUN_IN_BACKGROUND, FALSE.equals((String) args.get(TAG_TOOL_BLOCK)));
config.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, (String) args.get(TAG_TOOL_BUILD_TYPES));
config.setAttribute(IExternalToolConstants.ATTR_TOOL_ARGUMENTS, arguments);
config.setAttribute(IExternalToolConstants.ATTR_WORKING_DIRECTORY, (String) args.get(TAG_TOOL_DIRECTORY));
return config;
}
/**
* Returns a new working copy with the given external tool name and external
* tool type or <code>null</code> if no config could be created.
*/
private static ILaunchConfigurationWorkingCopy newConfig(String type, String name) {
if (type == null || name == null) {
return null;
}
ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
ILaunchConfigurationType configType;
if (IExternalToolConstants.TOOL_TYPE_ANT_BUILD.equals(type)) {
configType = manager.getLaunchConfigurationType(IExternalToolConstants.ID_ANT_BUILDER_LAUNCH_CONFIGURATION_TYPE);
} else if (IExternalToolConstants.TOOL_TYPE_PROGRAM.equals(type)) {
configType = manager.getLaunchConfigurationType(IExternalToolConstants.ID_PROGRAM_BUILDER_LAUNCH_CONFIGURATION_TYPE);
} else {
return null;
}
try {
return configType.newInstance(null, name);
} catch (CoreException e) {
return null;
}
}
/**
* Returns the tool name extracted from the given command argument map.
* Extraction is attempted using 2.0 and 2.1 external tool formats.
*/
public static String getNameFromCommandArgs(Map commandArgs) {
String name= (String) commandArgs.get(TAG_NAME);
if (name == null) {
name= (String) commandArgs.get(TAG_TOOL_NAME);
}
return name;
}
}
|
