source: josm/trunk/src/org/openstreetmap/josm/gui/io/CustomConfigurator.java

Last change on this file was 19050, checked in by taylor.smock, 2 days ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 28.8 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.io;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.io.ByteArrayInputStream;
7import java.io.CharArrayReader;
8import java.io.CharArrayWriter;
9import java.io.File;
10import java.io.IOException;
11import java.io.InputStream;
12import java.nio.charset.StandardCharsets;
13import java.nio.file.Files;
14import java.nio.file.InvalidPathException;
15import java.util.ArrayList;
16import java.util.Collection;
17import java.util.Collections;
18import java.util.HashMap;
19import java.util.HashSet;
20import java.util.List;
21import java.util.Locale;
22import java.util.Map;
23import java.util.Set;
24import java.util.regex.Matcher;
25import java.util.regex.Pattern;
26import java.util.stream.Collectors;
27
28import javax.swing.JOptionPane;
29import javax.swing.SwingUtilities;
30import javax.xml.parsers.DocumentBuilder;
31import javax.xml.parsers.ParserConfigurationException;
32import javax.xml.stream.XMLStreamException;
33import javax.xml.transform.OutputKeys;
34import javax.xml.transform.Transformer;
35import javax.xml.transform.TransformerException;
36import javax.xml.transform.TransformerFactoryConfigurationError;
37import javax.xml.transform.dom.DOMSource;
38import javax.xml.transform.stream.StreamResult;
39
40import org.openstreetmap.josm.data.Preferences;
41import org.openstreetmap.josm.data.PreferencesUtils;
42import org.openstreetmap.josm.data.Version;
43import org.openstreetmap.josm.gui.MainApplication;
44import org.openstreetmap.josm.gui.MainFrame;
45import org.openstreetmap.josm.plugins.PluginDownloadTask;
46import org.openstreetmap.josm.plugins.PluginInformation;
47import org.openstreetmap.josm.plugins.ReadLocalPluginInformationTask;
48import org.openstreetmap.josm.spi.preferences.Config;
49import org.openstreetmap.josm.spi.preferences.Setting;
50import org.openstreetmap.josm.tools.LanguageInfo;
51import org.openstreetmap.josm.tools.Logging;
52import org.openstreetmap.josm.tools.Utils;
53import org.openstreetmap.josm.tools.XmlUtils;
54import org.w3c.dom.DOMException;
55import org.w3c.dom.Document;
56import org.w3c.dom.Element;
57import org.w3c.dom.Node;
58import org.w3c.dom.NodeList;
59import org.xml.sax.SAXException;
60
61import jakarta.annotation.Nullable;
62
63/**
64 * Class to process configuration changes stored in XML
65 * can be used to modify preferences, store/delete files in .josm folders etc
66 */
67public final class CustomConfigurator {
68
69 private CustomConfigurator() {
70 // Hide default constructor for utils classes
71 }
72
73 /**
74 * Read configuration script from XML file, modifying main preferences
75 * @param dir - directory
76 * @param fileName - XML file name
77 */
78 public static void readXML(String dir, String fileName) {
79 readXML(new File(dir, fileName));
80 }
81
82 /**
83 * Read configuration script from XML file, modifying given preferences object
84 * @param file - file to open for reading XML
85 * @param prefs - arbitrary Preferences object to modify by script
86 */
87 public static void readXML(final File file, final Preferences prefs) {
88 synchronized (CustomConfigurator.class) {
89 busy = true;
90 }
91 new XMLCommandProcessor(prefs).openAndReadXML(file);
92 synchronized (CustomConfigurator.class) {
93 CustomConfigurator.class.notifyAll();
94 busy = false;
95 }
96 }
97
98 /**
99 * Read configuration script from XML file, modifying main preferences
100 * @param file - file to open for reading XML
101 */
102 public static void readXML(File file) {
103 readXML(file, Preferences.main());
104 }
105
106 /**
107 * Downloads file to one of JOSM standard folders
108 * @param address - URL to download
109 * @param path - file path relative to base where to put downloaded file
110 * @param base - only "prefs", "cache" and "plugins" allowed for standard folders
111 */
112 public static void downloadFile(String address, String path, String base) {
113 processDownloadOperation(address, path, getDirectoryByAbbr(base), true, false);
114 }
115
116 /**
117 * Downloads file to one of JOSM standard folders and unpack it as ZIP/JAR file
118 * @param address - URL to download
119 * @param path - file path relative to base where to put downloaded file
120 * @param base - only "prefs", "cache" and "plugins" allowed for standard folders
121 */
122 public static void downloadAndUnpackFile(String address, String path, String base) {
123 processDownloadOperation(address, path, getDirectoryByAbbr(base), true, true);
124 }
125
126 /**
127 * Downloads file to arbitrary folder
128 * @param address - URL to download
129 * @param path - file path relative to parentDir where to put downloaded file
130 * @param parentDir - folder where to put file
131 * @param mkdir - if true, non-existing directories will be created
132 * @param unzip - if true file wil be unzipped and deleted after download
133 */
134 public static void processDownloadOperation(String address, String path, String parentDir, boolean mkdir, boolean unzip) {
135 if (path.contains("..") || path.startsWith("/") || path.contains(":")) {
136 return; // some basic protection
137 }
138 File fOut = new File(parentDir, path);
139 DownloadFileTask downloadFileTask = new DownloadFileTask(MainApplication.getMainFrame(), address, fOut, mkdir, unzip);
140
141 MainApplication.worker.submit(downloadFileTask);
142 PreferencesUtils.log("Info: downloading file from %s to %s in background ", parentDir, fOut.getAbsolutePath());
143 if (unzip) PreferencesUtils.log("and unpacking it"); else PreferencesUtils.log("");
144 }
145
146 /**
147 * Simple function to show messageBox, may be used from JS API and from other code
148 * @param type - 'i','w','e','q','p' for Information, Warning, Error, Question, Message
149 * @param text - message to display, HTML allowed
150 */
151 public static void messageBox(String type, String text) {
152 char c = (Utils.isEmpty(type) ? "plain" : type).charAt(0);
153 MainFrame parent = MainApplication.getMainFrame();
154 switch (c) {
155 case 'i': JOptionPane.showMessageDialog(parent, text, tr("Information"), JOptionPane.INFORMATION_MESSAGE); break;
156 case 'w': JOptionPane.showMessageDialog(parent, text, tr("Warning"), JOptionPane.WARNING_MESSAGE); break;
157 case 'e': JOptionPane.showMessageDialog(parent, text, tr("Error"), JOptionPane.ERROR_MESSAGE); break;
158 case 'q': JOptionPane.showMessageDialog(parent, text, tr("Question"), JOptionPane.QUESTION_MESSAGE); break;
159 case 'p': JOptionPane.showMessageDialog(parent, text, tr("Message"), JOptionPane.PLAIN_MESSAGE); break;
160 default: Logging.warn("Unsupported messageBox type: " + c);
161 }
162 }
163
164 /**
165 * Simple function for choose window, may be used from JS API and from other code
166 * @param text - message to show, HTML allowed
167 * @param opts -
168 * @return number of pressed button, -1 if cancelled
169 */
170 public static int askForOption(String text, String opts) {
171 if (!opts.isEmpty()) {
172 return JOptionPane.showOptionDialog(MainApplication.getMainFrame(), text, "Question",
173 JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, opts.split(";", -1), 0);
174 } else {
175 return JOptionPane.showOptionDialog(MainApplication.getMainFrame(), text, "Question",
176 JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, null, 2);
177 }
178 }
179
180 /**
181 * Ask the user for text
182 * @param text The message for the user
183 * @return The text the user entered
184 */
185 @Nullable
186 public static String askForText(String text) {
187 String s = JOptionPane.showInputDialog(MainApplication.getMainFrame(), text, tr("Enter text"), JOptionPane.QUESTION_MESSAGE);
188 return s != null ? s.trim() : null;
189 }
190
191 /**
192 * This function exports part of user preferences to specified file.
193 * Default values are not saved.
194 * @param filename - where to export
195 * @param append - if true, resulting file cause appending to existing preferences
196 * @param keys - which preferences keys you need to export ("imagery.entries", for example)
197 */
198 public static void exportPreferencesKeysToFile(String filename, boolean append, String... keys) {
199 Set<String> keySet = new HashSet<>();
200 Collections.addAll(keySet, keys);
201 exportPreferencesKeysToFile(filename, append, keySet);
202 }
203
204 /**
205 * This function exports part of user preferences to specified file.
206 * Default values are not saved.
207 * Preference keys matching specified pattern are saved
208 * @param fileName - where to export
209 * @param append - if true, resulting file cause appending to existing preferences
210 * @param pattern - Regexp pattern for preferences keys you need to export (".*imagery.*", for example)
211 */
212 public static void exportPreferencesKeysByPatternToFile(String fileName, boolean append, String pattern) {
213 Map<String, Setting<?>> allSettings = Preferences.main().getAllSettings();
214 List<String> keySet = allSettings.keySet().stream().filter(key -> key.matches(pattern)).collect(Collectors.toList());
215 exportPreferencesKeysToFile(fileName, append, keySet);
216 }
217
218 /**
219 * Export specified preferences keys to configuration file
220 * @param filename - name of file
221 * @param append - will the preferences be appended to existing ones when file is imported later.
222 * Elsewhere preferences from file will replace existing keys.
223 * @param keys - collection of preferences key names to save
224 */
225 public static void exportPreferencesKeysToFile(String filename, boolean append, Collection<String> keys) {
226 Element root = null;
227 Document document = null;
228 Document exportDocument = null;
229
230 try {
231 String toXML = Preferences.main().toXML(true);
232 DocumentBuilder builder = XmlUtils.newSafeDOMBuilder();
233 document = builder.parse(new ByteArrayInputStream(toXML.getBytes(StandardCharsets.UTF_8)));
234 exportDocument = builder.newDocument();
235 root = document.getDocumentElement();
236 } catch (SAXException | IOException | ParserConfigurationException ex) {
237 Logging.log(Logging.LEVEL_WARN, "Error getting preferences to save:", ex);
238 }
239 if (root == null || exportDocument == null)
240 return;
241 try {
242 Element newRoot = exportDocument.createElement("config");
243 exportDocument.appendChild(newRoot);
244
245 Element prefElem = exportDocument.createElement("preferences");
246 prefElem.setAttribute("operation", append ? "append" : "replace");
247 newRoot.appendChild(prefElem);
248
249 NodeList childNodes = root.getChildNodes();
250 int n = childNodes.getLength();
251 for (int i = 0; i < n; i++) {
252 Node item = childNodes.item(i);
253 if (item.getNodeType() == Node.ELEMENT_NODE) {
254 String currentKey = ((Element) item).getAttribute("key");
255 if (keys.contains(currentKey)) {
256 Node imported = exportDocument.importNode(item, true);
257 prefElem.appendChild(imported);
258 }
259 }
260 }
261 File f = new File(filename);
262 Transformer ts = XmlUtils.newSafeTransformerFactory().newTransformer();
263 ts.setOutputProperty(OutputKeys.INDENT, "yes");
264 ts.transform(new DOMSource(exportDocument), new StreamResult(f.toURI().getPath()));
265 } catch (DOMException | TransformerFactoryConfigurationError | TransformerException ex) {
266 Logging.warn("Error saving preferences part:");
267 Logging.error(ex);
268 }
269 }
270
271 /**
272 * Delete a file
273 * @param path The path to delete inside the base directory
274 * @param base The base directory for the path
275 */
276 public static void deleteFile(String path, String base) {
277 String dir = getDirectoryByAbbr(base);
278 if (dir == null) {
279 PreferencesUtils.log("Error: Can not find base, use base=cache, base=prefs or base=plugins attribute.");
280 return;
281 }
282 PreferencesUtils.log("Delete file: %s\n", path);
283 if (path.contains("..") || path.startsWith("/") || path.contains(":")) {
284 return; // some basic protection
285 }
286 File fOut = new File(dir, path);
287 if (fOut.exists()) {
288 deleteFileOrDirectory(fOut);
289 }
290 }
291
292 /**
293 * Delete a file or a directory
294 * @param f The file or directory to delete
295 */
296 public static void deleteFileOrDirectory(File f) {
297 if (f.isDirectory()) {
298 File[] files = f.listFiles();
299 if (files != null) {
300 for (File f1: files) {
301 deleteFileOrDirectory(f1);
302 }
303 }
304 }
305 if (!Utils.deleteFile(f)) {
306 PreferencesUtils.log("Warning: Can not delete file "+f.getPath());
307 }
308 }
309
310 private static boolean busy;
311
312 /**
313 * Perform install, uninstall, and deletion operations on plugins
314 * @param install The {@code ;} delimited list of plugins to install
315 * @param uninstall The {@code ;} delimited list of plugins to uninstall
316 * @param delete The {@code ;} delimited list of plugins to delete
317 */
318 public static void pluginOperation(String install, String uninstall, String delete) {
319 final List<String> installList = new ArrayList<>();
320 final List<String> removeList = new ArrayList<>();
321 final List<String> deleteList = new ArrayList<>();
322 Collections.addAll(installList, install.toLowerCase(Locale.ENGLISH).split(";", -1));
323 Collections.addAll(removeList, uninstall.toLowerCase(Locale.ENGLISH).split(";", -1));
324 Collections.addAll(deleteList, delete.toLowerCase(Locale.ENGLISH).split(";", -1));
325 installList.remove("");
326 removeList.remove("");
327 deleteList.remove("");
328
329 if (!installList.isEmpty()) {
330 PreferencesUtils.log("Plugins install: "+installList);
331 }
332 if (!removeList.isEmpty()) {
333 PreferencesUtils.log("Plugins turn off: "+removeList);
334 }
335 if (!deleteList.isEmpty()) {
336 PreferencesUtils.log("Plugins delete: "+deleteList);
337 }
338
339 final ReadLocalPluginInformationTask task = new ReadLocalPluginInformationTask();
340 Runnable r = () -> {
341 if (task.isCanceled()) return;
342 synchronized (CustomConfigurator.class) {
343 try { // proceed only after all other tasks were finished
344 while (busy) CustomConfigurator.class.wait();
345 } catch (InterruptedException ex) {
346 Logging.log(Logging.LEVEL_WARN, "InterruptedException while reading local plugin information", ex);
347 Thread.currentThread().interrupt();
348 }
349
350 SwingUtilities.invokeLater(() -> {
351 List<PluginInformation> availablePlugins = task.getAvailablePlugins();
352 List<PluginInformation> toInstallPlugins = new ArrayList<>();
353 List<PluginInformation> toRemovePlugins = new ArrayList<>();
354 List<PluginInformation> toDeletePlugins = new ArrayList<>();
355 for (PluginInformation pi1: availablePlugins) {
356 String name = pi1.name.toLowerCase(Locale.ENGLISH);
357 if (installList.contains(name)) toInstallPlugins.add(pi1);
358 if (removeList.contains(name)) toRemovePlugins.add(pi1);
359 if (deleteList.contains(name)) toDeletePlugins.add(pi1);
360 }
361 if (!installList.isEmpty()) {
362 PluginDownloadTask pluginDownloadTask =
363 new PluginDownloadTask(MainApplication.getMainFrame(), toInstallPlugins, tr("Installing plugins"));
364 MainApplication.worker.submit(pluginDownloadTask);
365 }
366 List<String> pls = new ArrayList<>(Config.getPref().getList("plugins"));
367 for (PluginInformation pi2: toInstallPlugins) {
368 if (!pls.contains(pi2.name)) {
369 pls.add(pi2.name);
370 }
371 }
372 for (PluginInformation pi3: toRemovePlugins) {
373 pls.remove(pi3.name);
374 }
375 for (PluginInformation pi4: toDeletePlugins) {
376 pls.remove(pi4.name);
377 Utils.deleteFile(new File(Preferences.main().getPluginsDirectory(), pi4.name+".jar"));
378 }
379 Config.getPref().putList("plugins", pls);
380 });
381 }
382 };
383 MainApplication.worker.submit(task);
384 MainApplication.worker.submit(r);
385 }
386
387 private static String getDirectoryByAbbr(String base) {
388 String dir;
389 if ("prefs".equals(base) || base.isEmpty()) {
390 dir = Config.getDirs().getPreferencesDirectory(false).getAbsolutePath();
391 } else if ("cache".equals(base)) {
392 dir = Config.getDirs().getCacheDirectory(false).getAbsolutePath();
393 } else if ("plugins".equals(base)) {
394 dir = Preferences.main().getPluginsDirectory().getAbsolutePath();
395 } else {
396 dir = null;
397 }
398 return dir;
399 }
400
401 /**
402 * Read preferences from xml files
403 */
404 public static class XMLCommandProcessor {
405
406 private final Preferences mainPrefs;
407 private final Map<String, Element> tasksMap = new HashMap<>();
408 private final Map<String, String> environment = new HashMap<>();
409
410 private boolean lastV; // last If condition result
411
412 /**
413 * Read preferences from an XML file
414 * @param file The file to read custom preferences from
415 */
416 public void openAndReadXML(File file) {
417 PreferencesUtils.log("-- Reading custom preferences from " + file.getAbsolutePath() + " --");
418 try {
419 String fileDir = file.getParentFile().getAbsolutePath();
420 environment.put("scriptDir", normalizeDirName(fileDir));
421 try (InputStream is = Files.newInputStream(file.toPath())) {
422 openAndReadXML(is);
423 }
424 } catch (IOException | SecurityException | InvalidPathException ex) {
425 PreferencesUtils.log(ex, "Error reading custom preferences:");
426 }
427 }
428
429 /**
430 * Read custom preferences from an XML {@link InputStream}
431 * @param is The {@link InputStream} to read from
432 */
433 public void openAndReadXML(InputStream is) {
434 try {
435 Document document = XmlUtils.parseSafeDOM(is);
436 synchronized (CustomConfigurator.class) {
437 processXML(document);
438 }
439 } catch (SAXException | IOException | ParserConfigurationException ex) {
440 PreferencesUtils.log(ex, "Error reading custom preferences:");
441 }
442 PreferencesUtils.log("-- Reading complete --");
443 }
444
445 /**
446 * Create a new {@link XMLCommandProcessor}
447 * @param mainPrefs The preferences to modify with custom preferences
448 */
449 public XMLCommandProcessor(Preferences mainPrefs) {
450 this.mainPrefs = mainPrefs;
451 PreferencesUtils.resetLog();
452 setVar("homeDir", normalizeDirName(Config.getDirs().getPreferencesDirectory(false).getAbsolutePath()));
453 setVar("josmVersion", String.valueOf(Version.getInstance().getVersion()));
454 }
455
456 private void processXML(Document document) {
457 processXmlFragment(document.getDocumentElement());
458 }
459
460 private void processXmlFragment(Element root) {
461 NodeList childNodes = root.getChildNodes();
462 int nops = childNodes.getLength();
463 for (int i = 0; i < nops; i++) {
464 Node item = childNodes.item(i);
465 if (item.getNodeType() != Node.ELEMENT_NODE) continue;
466 String elementName = item.getNodeName();
467 Element elem = (Element) item;
468
469 switch (elementName) {
470 case "var":
471 setVar(elem.getAttribute("name"), evalVars(elem.getAttribute("value")));
472 break;
473 case "task":
474 tasksMap.put(elem.getAttribute("name"), elem);
475 break;
476 case "runtask":
477 if (processRunTaskElement(elem)) return;
478 break;
479 case "ask":
480 processAskElement(elem);
481 break;
482 case "if":
483 processIfElement(elem);
484 break;
485 case "else":
486 processElseElement(elem);
487 break;
488 case "break":
489 return;
490 case "plugin":
491 processPluginInstallElement(elem);
492 break;
493 case "messagebox":
494 processMsgBoxElement(elem);
495 break;
496 case "preferences":
497 processPreferencesElement(elem);
498 break;
499 case "download":
500 processDownloadElement(elem);
501 break;
502 case "delete":
503 processDeleteElement(elem);
504 break;
505 default:
506 PreferencesUtils.log("Error: Unknown element " + elementName);
507 }
508 }
509 }
510
511 private void processPreferencesElement(Element item) {
512 String oper = evalVars(item.getAttribute("operation"));
513
514 if ("delete-keys".equals(oper)) {
515 String pattern = evalVars(item.getAttribute("pattern"));
516 String key = evalVars(item.getAttribute("key"));
517 PreferencesUtils.deletePreferenceKey(key, mainPrefs);
518 PreferencesUtils.deletePreferenceKeyByPattern(pattern, mainPrefs);
519 return;
520 }
521
522 Preferences tmpPref = readPreferencesFromDOMElement(item);
523 PreferencesUtils.showPrefs(tmpPref);
524
525 if ("replace".equals(oper)) {
526 PreferencesUtils.log("Preferences replace: %d keys: %s\n",
527 tmpPref.getAllSettings().size(), tmpPref.getAllSettings().keySet().toString());
528 PreferencesUtils.replacePreferences(tmpPref, mainPrefs);
529 } else if ("append".equals(oper)) {
530 PreferencesUtils.log("Preferences append: %d keys: %s\n",
531 tmpPref.getAllSettings().size(), tmpPref.getAllSettings().keySet().toString());
532 PreferencesUtils.appendPreferences(tmpPref, mainPrefs);
533 } else if ("delete-values".equals(oper)) {
534 PreferencesUtils.deletePreferenceValues(tmpPref, mainPrefs);
535 }
536 }
537
538 private void processDeleteElement(Element item) {
539 String path = evalVars(item.getAttribute("path"));
540 String base = evalVars(item.getAttribute("base"));
541 deleteFile(path, base);
542 }
543
544 private void processDownloadElement(Element item) {
545 String base = evalVars(item.getAttribute("base"));
546 String dir = getDirectoryByAbbr(base);
547 if (dir == null) {
548 PreferencesUtils.log("Error: Can not find directory to place file, use base=cache, base=prefs or base=plugins attribute.");
549 return;
550 }
551
552 String path = evalVars(item.getAttribute("path"));
553 if (path.contains("..") || path.startsWith("/") || path.contains(":")) {
554 return; // some basic protection
555 }
556
557 String address = evalVars(item.getAttribute("url"));
558 if (address.isEmpty() || path.isEmpty()) {
559 PreferencesUtils.log("Error: Please specify url=\"where to get file\" and path=\"where to place it\"");
560 return;
561 }
562
563 String unzip = evalVars(item.getAttribute("unzip"));
564 String mkdir = evalVars(item.getAttribute("mkdir"));
565 processDownloadOperation(address, path, dir, "true".equals(mkdir), "true".equals(unzip));
566 }
567
568 private static void processPluginInstallElement(Element elem) {
569 String install = elem.getAttribute("install");
570 String uninstall = elem.getAttribute("remove");
571 String delete = elem.getAttribute("delete");
572 pluginOperation(install, uninstall, delete);
573 }
574
575 private void processMsgBoxElement(Element elem) {
576 String text = evalVars(elem.getAttribute("text"));
577 String locText = evalVars(elem.getAttribute(LanguageInfo.getJOSMLocaleCode()+".text"));
578 if (!locText.isEmpty()) text = locText;
579
580 String type = evalVars(elem.getAttribute("type"));
581 messageBox(type, text);
582 }
583
584 private void processAskElement(Element elem) {
585 String text = evalVars(elem.getAttribute("text"));
586 String locText = evalVars(elem.getAttribute(LanguageInfo.getJOSMLocaleCode()+".text"));
587 if (!locText.isEmpty()) text = locText;
588 String varAttribute = elem.getAttribute("var");
589 if (varAttribute.isEmpty()) varAttribute = "result";
590
591 String input = evalVars(elem.getAttribute("input"));
592 if ("true".equals(input)) {
593 setVar(varAttribute, askForText(text));
594 } else {
595 String opts = evalVars(elem.getAttribute("options"));
596 String locOpts = evalVars(elem.getAttribute(LanguageInfo.getJOSMLocaleCode()+".options"));
597 if (!locOpts.isEmpty()) opts = locOpts;
598 setVar(varAttribute, String.valueOf(askForOption(text, opts)));
599 }
600 }
601
602 /**
603 * Set a variable in the environment
604 * @param name The name of the environment variable
605 * @param value The value for the environment variable
606 */
607 public void setVar(String name, String value) {
608 environment.put(name, value);
609 }
610
611 private void processIfElement(Element elem) {
612 String realValue = evalVars(elem.getAttribute("test"));
613 boolean v = false;
614 if ("true".equals(realValue) || "false".equals(realValue)) {
615 processXmlFragment(elem);
616 v = true;
617 } else {
618 PreferencesUtils.log("Error: Illegal test expression in if: %s=%s\n", elem.getAttribute("test"), realValue);
619 }
620
621 lastV = v;
622 }
623
624 private void processElseElement(Element elem) {
625 if (!lastV) {
626 processXmlFragment(elem);
627 }
628 }
629
630 private boolean processRunTaskElement(Element elem) {
631 String taskName = elem.getAttribute("name");
632 Element task = tasksMap.get(taskName);
633 if (task != null) {
634 PreferencesUtils.log("EXECUTING TASK "+taskName);
635 processXmlFragment(task); // process task recursively
636 } else {
637 PreferencesUtils.log("Error: Can not execute task "+taskName);
638 return true;
639 }
640 return false;
641 }
642
643 /**
644 * substitute ${expression} = expression evaluated by JavaScript
645 * @param s string
646 * @return evaluation result
647 */
648 private String evalVars(String s) {
649 Matcher mr = Pattern.compile("\\$\\{(?<identifier>[^}]*)}").matcher(s);
650 StringBuffer sb = new StringBuffer();
651 while (mr.find()) {
652 String identifier = mr.group("identifier");
653 String value = environment.get(identifier);
654 mr.appendReplacement(sb, String.valueOf(value));
655 }
656 mr.appendTail(sb);
657 return sb.toString();
658 }
659
660 private Preferences readPreferencesFromDOMElement(Element item) {
661 Preferences tmpPref = new Preferences();
662 try {
663 Transformer xformer = XmlUtils.newSafeTransformerFactory().newTransformer();
664 CharArrayWriter outputWriter = new CharArrayWriter(8192);
665 StreamResult out = new StreamResult(outputWriter);
666
667 xformer.transform(new DOMSource(item), out);
668
669 String fragmentWithReplacedVars = evalVars(outputWriter.toString());
670
671 try (CharArrayReader reader = new CharArrayReader(fragmentWithReplacedVars.toCharArray())) {
672 tmpPref.fromXML(reader);
673 }
674 } catch (TransformerException | XMLStreamException | IOException ex) {
675 PreferencesUtils.log(ex, "Error: can not read XML fragment:");
676 }
677
678 return tmpPref;
679 }
680
681 private static String normalizeDirName(String dir) {
682 String s = dir.replace('\\', '/');
683 if (s.endsWith("/")) s = s.substring(0, s.length()-1);
684 return s;
685 }
686 }
687}
Note: See TracBrowser for help on using the repository browser.