Refactory: remove unused classes, imports, fields and methods.
[phpeclipse.git] / net.sourceforge.phpeclipse.externaltools / src / net / sourceforge / phpdt / externaltools / internal / registry / ExternalToolMigration.java
1 package net.sourceforge.phpdt.externaltools.internal.registry;
2
3 /**********************************************************************
4  Copyright (c) 2002 IBM Corp. and others. All rights reserved.
5  This file is made available under the terms of the Common Public License v1.0
6  which accompanies this distribution, and is available at
7  http://www.eclipse.org/legal/cpl-v10.html
8  �
9  Contributors:
10  **********************************************************************/
11
12 //import java.io.File;
13 //import java.io.FileInputStream;
14 //import java.io.FileNotFoundException;
15 //import java.io.IOException;
16 //import java.io.InputStreamReader;
17 import java.util.ArrayList;
18 //import java.util.HashMap;
19 import java.util.Map;
20 import java.util.StringTokenizer;
21
22 import net.sourceforge.phpdt.externaltools.model.IExternalToolConstants;
23 import net.sourceforge.phpdt.externaltools.model.ToolUtil;
24 //import net.sourceforge.phpeclipse.externaltools.ExternalToolsPlugin;
25
26 import org.eclipse.core.runtime.CoreException;
27 //import org.eclipse.core.runtime.IPath;
28 import org.eclipse.debug.core.DebugPlugin;
29 import org.eclipse.debug.core.ILaunchConfigurationType;
30 import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
31 import org.eclipse.debug.core.ILaunchManager;
32 //import org.eclipse.ui.IMemento;
33 //import org.eclipse.ui.WorkbenchException;
34 //import org.eclipse.ui.XMLMemento;
35
36 /**
37  * Responsible reading an old external tool format and creating and migrating it
38  * to create a new external tool.
39  */
40 public final class ExternalToolMigration {
41         //private static final String SEPERATOR = ";"; //$NON-NLS-1$    
42
43         //private static final String STATE_FILE_NAME_OLD = "oldexternaltools.xml"; //$NON-NLS-1$
44
45         //private static final String STATE_FILE_NAME = "externaltools.xml"; //$NON-NLS-1$
46
47         //private static final String TAG_EXTERNALTOOLS = "externaltools"; //$NON-NLS-1$
48
49         //private static final String TAG_TOOL = "tool"; //$NON-NLS-1$
50
51         //private static final String TAG_ENTRY = "entry"; //$NON-NLS-1$
52
53         // private static final String TAG_KEY = "key"; //$NON-NLS-1$
54 //      private static final String TAG_VALUE = "value"; //$NON-NLS-1$
55
56         /*
57          * Ant tags
58          */
59         // public static final String RUN_TARGETS_ATTRIBUTE =
60         // IExternalToolConstants.TOOL_TYPE_ANT_BUILD + ".runTargets";
61         // //$NON-NLS-1$;
62         /*
63          * 2.0 External Tool Tags
64          */
65         private static final String TAG_TOOL_TYPE = "!{tool_type}"; //$NON-NLS-1$
66
67         private static final String TAG_TOOL_NAME = "!{tool_name}"; //$NON-NLS-1$
68
69         private static final String TAG_TOOL_LOCATION = "!{tool_loc}"; //$NON-NLS-1$
70
71         private static final String TAG_TOOL_ARGUMENTS = "!{tool_args}"; //$NON-NLS-1$
72
73         private static final String TAG_TOOL_DIRECTORY = "!{tool_dir}"; //$NON-NLS-1$
74
75         private static final String TAG_TOOL_REFRESH = "!{tool_refresh}"; //$NON-NLS-1$
76
77         private static final String TAG_TOOL_SHOW_LOG = "!{tool_show_log}"; //$NON-NLS-1$
78
79         private static final String TAG_TOOL_BUILD_TYPES = "!{tool_build_types}"; //$NON-NLS-1$
80
81         private static final String TAG_TOOL_BLOCK = "!{tool_block}"; //$NON-NLS-1$
82
83         // Known kind of tools
84         //private static final String TOOL_TYPE_PROGRAM = "net.sourceforge.phpdt.externaltools.type.program"; //$NON-NLS-1$
85
86         // private static final String TOOL_TYPE_ANT =
87         // "org.eclipse.ui.externaltools.type.ant"; //$NON-NLS-1$
88
89         /*
90          * 2.1 External Tool Keys
91          */
92         //private static final String TAG_EXTERNAL_TOOL = "externalTool"; //$NON-NLS-1$
93
94         private static final String TAG_TYPE = "type"; //$NON-NLS-1$
95
96         private static final String TAG_NAME = "name"; //$NON-NLS-1$
97
98         private static final String TAG_LOCATION = "location"; //$NON-NLS-1$
99
100         private static final String TAG_WORK_DIR = "workDirectory"; //$NON-NLS-1$
101
102         private static final String TAG_CAPTURE_OUTPUT = "captureOutput"; //$NON-NLS-1$
103
104         private static final String TAG_SHOW_CONSOLE = "showConsole"; //$NON-NLS-1$
105
106         private static final String TAG_RUN_BKGRND = "runInBackground"; //$NON-NLS-1$
107
108         //private static final String TAG_OPEN_PERSP = "openPerspective"; //$NON-NLS-1$
109
110         private static final String TAG_PROMPT_ARGS = "promptForArguments"; //$NON-NLS-1$
111
112         //private static final String TAG_SHOW_MENU = "showInMenu"; //$NON-NLS-1$
113
114         //private static final String TAG_SAVE_DIRTY = "saveDirtyEditors"; //$NON-NLS-1$
115
116         private static final String TAG_ARGS = "arguments"; //$NON-NLS-1$
117
118         private static final String TAG_REFRESH_SCOPE = "refreshScope"; //$NON-NLS-1$
119
120         private static final String TAG_REFRESH_RECURSIVE = "refreshRecursive"; //$NON-NLS-1$
121
122         private static final String TAG_RUN_BUILD_KINDS = "runForBuildKinds"; //$NON-NLS-1$
123
124         private static final String TAG_EXTRA_ATTR = "extraAttribute"; //$NON-NLS-1$
125
126         //private static final String TAG_KEY = "key"; //$NON-NLS-1$
127
128         private static final String TAG_VERSION = "version"; //$NON-NLS-1$
129
130         //private static final String BUILD_TYPE_SEPARATOR = ","; //$NON-NLS-1$
131
132         private static final String EXTRA_ATTR_SEPARATOR = "="; //$NON-NLS-1$
133
134         private static final String VERSION_21 = "2.1"; //$NON-NLS-1$;
135
136         private static final String TRUE = "true"; //$NON-NLS-1$
137
138         private static final String FALSE = "false"; //$NON-NLS-1$
139
140         /**
141          * Allows no instances.
142          */
143         private ExternalToolMigration() {
144                 super();
145         }
146
147         /**
148          * Loads the external tools from storage and adds them to the registry.
149          */
150         /* package */
151         // This method is not called. It is left here in case
152         // we decide to do tool migration in the future
153 //      private static void readInOldTools() {
154 //              readIn20Tools();
155 //              readIn21Tools();
156 //      }
157
158 //      private static void readIn21Tools() {
159 //      }
160
161 //      public static void readIn20Tools() {
162 //              boolean migrationSuccessful = true;
163 //              IPath path = ExternalToolsPlugin.getDefault().getStateLocation();
164 //              File file = path.append(STATE_FILE_NAME).toFile();
165 //              if (!file.exists())
166 //                      return;
167 //
168 //              InputStreamReader reader = null;
169 //              try {
170 //                      FileInputStream input = new FileInputStream(file);
171 //                      reader = new InputStreamReader(input, "utf-8"); //$NON-NLS-1$
172 //                      XMLMemento memento = XMLMemento.createReadRoot(reader);
173 //
174 //                      // Get the external tool children element
175 //                      IMemento[] tools = memento.getChildren(TAG_TOOL);
176 //                      for (int i = 0; i < tools.length; i++) {
177 //                              HashMap args = new HashMap();
178 //                              IMemento[] entries = tools[i].getChildren(TAG_ENTRY);
179 //                              for (int j = 0; j < entries.length; j++) {
180 //                                      String key = entries[j].getString(TAG_KEY);
181 //                                      if (key != null) {
182 //                                              String value = entries[j].getTextData();
183 //                                              args.put(key, value);
184 //                                      }
185 //                              }
186 //                              ILaunchConfigurationWorkingCopy config = configFromArgumentMap(args);
187 //                              if (config != null) {
188 //                                      try {
189 //                                              config.doSave();
190 //                                      } catch (CoreException e) {
191 //                                              // TODO: Decide what to do when saving fails.
192 //                                      }
193 //                              }
194 //                      }
195 //              } catch (FileNotFoundException e) {
196 //                      // Silently ignore this...
197 //              } catch (IOException e) {
198 //                      ExternalToolsPlugin.getDefault().log(
199 //                                      "File I/O error with reading old external tools.", e);
200 //                      migrationSuccessful = false;
201 //              } catch (WorkbenchException e) {
202 //                      ExternalToolsPlugin.getDefault().getLog().log(e.getStatus());
203 //                      System.err
204 //                                      .println("Error reading old external tools. See .log file for more details");
205 //                      migrationSuccessful = false;
206 //              } finally {
207 //                      if (reader != null) {
208 //                              try {
209 //                                      reader.close();
210 //                              } catch (IOException e) {
211 //                                      ExternalToolsPlugin.getDefault().log(
212 //                                                      "Unable to close external tool old state reader.",
213 //                                                      e);
214 //                              }
215 //                      }
216 //              }
217 //
218 //              if (migrationSuccessful) {
219 //                      if (!file.renameTo(path.append(STATE_FILE_NAME_OLD).toFile())) {
220 //                              ExternalToolsPlugin
221 //                                              .getDefault()
222 //                                              .log(
223 //                                                              "Unable to rename old external tool state file. Please rename externaltools.xml to oldexternaltools.xml manually.",
224 //                                                              null);
225 //                              System.err
226 //                                              .println("Unable to rename old external tool state file. Please rename externaltools.xml to oldexternaltools.xml manually.");
227 //                      }
228 //              }
229 //      }
230
231         /**
232          * Returns a launch configuration working copy from the argument map or
233          * <code>null</code> if the given map cannot be interpreted as a 2.0 or
234          * 2.1 branch external tool. The returned working copy will be unsaved and
235          * its location will be set to the metadata area.
236          */
237         public static ILaunchConfigurationWorkingCopy configFromArgumentMap(Map args) {
238                 String version = (String) args.get(TAG_VERSION);
239                 if (VERSION_21.equals(version)) {
240                         return configFrom21ArgumentMap(args);
241                 }
242                 return configFrom20ArgumentMap(args);
243         }
244
245         public static ILaunchConfigurationWorkingCopy configFrom21ArgumentMap(
246                         Map commandArgs) {
247                 String name = (String) commandArgs.get(TAG_NAME);
248                 String type = (String) commandArgs.get(TAG_TYPE);
249
250                 ILaunchConfigurationWorkingCopy config = newConfig(type, name);
251                 if (config == null) {
252                         return null;
253                 }
254
255                 config.setAttribute(IExternalToolConstants.ATTR_LOCATION,
256                                 (String) commandArgs.get(TAG_LOCATION));
257                 config.setAttribute(IExternalToolConstants.ATTR_WORKING_DIRECTORY,
258                                 (String) commandArgs.get(TAG_WORK_DIR));
259                 config.setAttribute(IExternalToolConstants.ATTR_CAPTURE_OUTPUT, TRUE
260                                 .equals((String) commandArgs.get(TAG_CAPTURE_OUTPUT)));
261                 config.setAttribute(IExternalToolConstants.ATTR_SHOW_CONSOLE, TRUE
262                                 .equals((String) commandArgs.get(TAG_SHOW_CONSOLE)));
263                 config.setAttribute(IExternalToolConstants.ATTR_RUN_IN_BACKGROUND, TRUE
264                                 .equals((String) commandArgs.get(TAG_RUN_BKGRND)));
265                 config.setAttribute(IExternalToolConstants.ATTR_PROMPT_FOR_ARGUMENTS,
266                                 TRUE.equals((String) commandArgs.get(TAG_PROMPT_ARGS)));
267                 config.setAttribute(IExternalToolConstants.ATTR_REFRESH_SCOPE,
268                                 (String) commandArgs.get(TAG_REFRESH_SCOPE));
269                 config.setAttribute(IExternalToolConstants.ATTR_REFRESH_RECURSIVE, TRUE
270                                 .equals((String) commandArgs.get(TAG_REFRESH_RECURSIVE)));
271
272                 config.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS,
273                                 (String) commandArgs.get(TAG_RUN_BUILD_KINDS));
274
275                 String args = (String) commandArgs.get(TAG_ARGS);
276                 if (args != null) {
277                         config.setAttribute(IExternalToolConstants.ATTR_TOOL_ARGUMENTS,
278                                         args);
279                 }
280
281                 String extraAttributes = (String) commandArgs.get(TAG_EXTRA_ATTR);
282                 if (extraAttributes != null) {
283                         StringTokenizer tokenizer = new StringTokenizer(extraAttributes,
284                                         EXTRA_ATTR_SEPARATOR);
285                         while (tokenizer.hasMoreTokens()) {
286                                 String key = tokenizer.nextToken();
287                                 if (!tokenizer.hasMoreTokens())
288                                         break;
289                                 String value = tokenizer.nextToken();
290                                 // if (key.equals(RUN_TARGETS_ATTRIBUTE)) {
291                                 // // 2.1 implementation only defined 1 "extra attribute"
292                                 // config.setAttribute(IExternalToolConstants.ATTR_ANT_TARGETS,
293                                 // value);
294                                 // }
295                         }
296                 }
297                 return config;
298         }
299
300         /**
301          * Creates an external tool from the map.
302          */
303         public static ILaunchConfigurationWorkingCopy configFrom20ArgumentMap(
304                         Map args) {
305                 // Update the type...
306                 String type = (String) args.get(TAG_TOOL_TYPE);
307                 // if (TOOL_TYPE_ANT.equals(type))
308                 // type = IExternalToolConstants.TOOL_TYPE_ANT_BUILD;
309                 // else
310                 type = IExternalToolConstants.TOOL_TYPE_PROGRAM;
311
312                 String name = (String) args.get(TAG_TOOL_NAME);
313
314                 ILaunchConfigurationWorkingCopy config = newConfig(type, name);
315                 if (config == null) {
316                         return null;
317                 }
318
319                 // Update the location...
320                 String location = (String) args.get(TAG_TOOL_LOCATION);
321                 if (location != null) {
322                         ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(
323                                         location, 0);
324                         if (IExternalToolConstants.VAR_WORKSPACE_LOC.equals(varDef.name)) {
325                                 location = ToolUtil.buildVariableTag(
326                                                 IExternalToolConstants.VAR_RESOURCE_LOC,
327                                                 varDef.argument);
328                         }
329                         config.setAttribute(IExternalToolConstants.ATTR_LOCATION, location);
330                 }
331
332                 // Update the refresh scope...
333                 String refresh = (String) args.get(TAG_TOOL_REFRESH);
334                 if (refresh != null) {
335                         ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(
336                                         refresh, 0);
337                         if ("none".equals(varDef.name)) { //$NON-NLS-1$
338                                 refresh = null;
339                         }
340                         config.setAttribute(IExternalToolConstants.ATTR_REFRESH_SCOPE,
341                                         refresh);
342                 }
343
344                 // Update the arguments
345                 String arguments = (String) args.get(TAG_TOOL_ARGUMENTS);
346                 String targetNames = null;
347                 if (arguments != null) {
348                         int start = 0;
349                         ArrayList targets = new ArrayList();
350                         StringBuffer buffer = new StringBuffer();
351                         ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(
352                                         arguments, start);
353                         while (varDef.end != -1) {
354                                 if ("ant_target".equals(varDef.name) && varDef.argument != null) { //$NON-NLS-1$
355                                         targets.add(varDef.argument);
356                                         buffer.append(arguments.substring(start, varDef.start));
357                                 } else {
358                                         buffer.append(arguments.substring(start, varDef.end));
359                                 }
360                                 start = varDef.end;
361                                 varDef = ToolUtil.extractVariableTag(arguments, start);
362                         }
363                         buffer.append(arguments.substring(start, arguments.length()));
364                         arguments = buffer.toString();
365
366                         buffer.setLength(0);
367                         for (int i = 0; i < targets.size(); i++) {
368                                 String target = (String) targets.get(i);
369                                 if (target != null && target.length() > 0) {
370                                         buffer.append(target);
371                                         buffer.append(","); //$NON-NLS-1$
372                                 }
373                         }
374                         targetNames = buffer.toString();
375                 }
376                 if (targetNames != null && targetNames.length() > 0) {
377                         config.setAttribute(IExternalToolConstants.ATTR_ANT_TARGETS,
378                                         targetNames);
379                 }
380
381                 // Collect the rest of the information
382                 config.setAttribute(IExternalToolConstants.ATTR_SHOW_CONSOLE, TRUE
383                                 .equals((String) args.get(TAG_TOOL_SHOW_LOG)));
384                 config.setAttribute(IExternalToolConstants.ATTR_CAPTURE_OUTPUT, TRUE
385                                 .equals((String) args.get(TAG_TOOL_SHOW_LOG)));
386                 config.setAttribute(IExternalToolConstants.ATTR_RUN_IN_BACKGROUND,
387                                 FALSE.equals((String) args.get(TAG_TOOL_BLOCK)));
388                 config.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS,
389                                 (String) args.get(TAG_TOOL_BUILD_TYPES));
390                 config.setAttribute(IExternalToolConstants.ATTR_TOOL_ARGUMENTS,
391                                 arguments);
392                 config.setAttribute(IExternalToolConstants.ATTR_WORKING_DIRECTORY,
393                                 (String) args.get(TAG_TOOL_DIRECTORY));
394                 return config;
395         }
396
397         /**
398          * Returns a new working copy with the given external tool name and external
399          * tool type or <code>null</code> if no config could be created.
400          */
401         private static ILaunchConfigurationWorkingCopy newConfig(String type,
402                         String name) {
403                 if (type == null || name == null) {
404                         return null;
405                 }
406                 ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
407                 ILaunchConfigurationType configType;
408                 // if (IExternalToolConstants.TOOL_TYPE_ANT_BUILD.equals(type)) {
409                 // configType =
410                 // manager.getLaunchConfigurationType(IExternalToolConstants.ID_ANT_BUILDER_LAUNCH_CONFIGURATION_TYPE);
411                 // } else
412                 if (IExternalToolConstants.TOOL_TYPE_PROGRAM.equals(type)) {
413                         configType = manager
414                                         .getLaunchConfigurationType(IExternalToolConstants.ID_PROGRAM_BUILDER_LAUNCH_CONFIGURATION_TYPE);
415                 } else {
416                         return null;
417                 }
418                 try {
419                         return configType.newInstance(null, name);
420                 } catch (CoreException e) {
421                         return null;
422                 }
423         }
424
425         /**
426          * Returns the tool name extracted from the given command argument map.
427          * Extraction is attempted using 2.0 and 2.1 external tool formats.
428          */
429 //      public static String getNameFromCommandArgs(Map commandArgs) {
430 //              String name = (String) commandArgs.get(TAG_NAME);
431 //              if (name == null) {
432 //                      name = (String) commandArgs.get(TAG_TOOL_NAME);
433 //              }
434 //              return name;
435 //      }
436
437 }