Ticket #17268: clear_ignored_errors_v13.patch

src/org/openstreetmap/josm/data/preferences/sources/ValidatorPrefHelper.java

@@ -10 +10 @@
 import java.util.Map;
 
 import org.openstreetmap.josm.data.preferences.BooleanProperty;
+import org.openstreetmap.josm.data.preferences.ListProperty;
 import org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker;
 
 /**
@@ -44 +45 @@
     /** The preferences for ignored severity other */
     public static final BooleanProperty PREF_OTHER = new BooleanProperty(PREFIX + ".other", false);
 
+    /** The preferences key for the ignorelist */
+    public static final ListProperty PREF_IGNORELIST = new ListProperty(PREFIX + ".ignorelist", new ArrayList<String>());
+
+    /** The preferences key for the ignorelist backup */
+    public static final ListProperty PREF_IGNORELIST_BACKUP = new ListProperty(PREFIX + ".ignorelist.bak", new ArrayList<String>());
     /**
      * The preferences key for enabling the permanent filtering
      * of the displayed errors in the tree regarding the current selection

src/org/openstreetmap/josm/data/validation/OsmValidator.java

@@ -7 +7 @@
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -89 +88 @@
     private static double griddetail;
 
     private static final Collection<String> ignoredErrors = new TreeSet<>();
+    /**
+     * The preference value for the validator's ignorederrors list
+     */
+    public static final String prefIgnoredErrors = "validator.ignorederrors";
 
     /**
      * All registered tests
@@ -204 +207 @@
     private static void loadIgnoredErrors() {
         ignoredErrors.clear();
         if (ValidatorPrefHelper.PREF_USE_IGNORE.get()) {
+            ignoredErrors.addAll(ValidatorPrefHelper.PREF_IGNORELIST.get());
             Path path = Paths.get(getValidatorDir()).resolve("ignorederrors");
             try {
                 if (path.toFile().exists()) {
                     try {
                         ignoredErrors.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
+                        saveIgnoredErrors();
+                        Files.deleteIfExists(path);
                     } catch (FileNotFoundException e) {
                         Logging.debug(Logging.getErrorMessage(e));
                     } catch (IOException e) {
@@ -241 +247 @@
     }
 
     /**
+     * Get the list of all ignored errors
+     * @return The <code>Collection&ltString&gt</code> of errors that are ignored
+     */
+    public static Collection<String> getIgnoredErrors() {
+        return ignoredErrors;
+    }
+
+    /**
+     * Reset the error list by deleting ignorederrors
+     */
+    public static void resetErrorList() {
+        saveIgnoredErrors();
+        backupErrorList();
+        ValidatorPrefHelper.PREF_IGNORELIST.put(null);
+        OsmValidator.initialize();
+    }
+
+    /**
+     * Restore the error list by copying ignorederrors.bak to ignorederrors
+     */
+    public static void restoreErrorList() {
+        saveIgnoredErrors();
+        List<String> tlist = ValidatorPrefHelper.PREF_IGNORELIST_BACKUP.get();
+        backupErrorList();
+        ValidatorPrefHelper.PREF_IGNORELIST.put(tlist);
+        OsmValidator.initialize();
+    }
+
+    private static void backupErrorList() {
+        List<String> tlist = ValidatorPrefHelper.PREF_IGNORELIST.get();
+        if (tlist.isEmpty()) tlist = null;
+        ValidatorPrefHelper.PREF_IGNORELIST_BACKUP.put(tlist);
+    }
+
+    /**
      * Saves the names of the ignored errors to a file
      */
     public static void saveIgnoredErrors() {
-        try (PrintWriter out = new PrintWriter(new File(getValidatorDir(), "ignorederrors"), StandardCharsets.UTF_8.name())) {
-            for (String e : ignoredErrors) {
-                out.println(e);
-            }
-        } catch (IOException e) {
-            Logging.error(e);
-        }
+        List<String> list = new ArrayList<>(ignoredErrors);
+        Collections.sort(list);
+        ValidatorPrefHelper.PREF_IGNORELIST.put(list);
     }
 
     /**

src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

@@ -46 +46 @@
 import org.openstreetmap.josm.data.validation.OsmValidator;
 import org.openstreetmap.josm.data.validation.TestError;
 import org.openstreetmap.josm.data.validation.ValidatorVisitor;
+import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
 import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
 import org.openstreetmap.josm.gui.PopupMenuHandler;
 import org.openstreetmap.josm.gui.SideButton;
@@ -85 +87 @@
     private final SideButton fixButton;
     /** The ignore button */
     private final SideButton ignoreButton;
+    /** The reset ignorelist button */
+    private final SideButton resetignorelistButton;
     /** The select button */
     private final SideButton selectButton;
     /** The lookup button */
@@ -174 +178 @@
             });
             ignoreButton.setEnabled(false);
             buttons.add(ignoreButton);
+            // Clear the backup ignore list
+            ValidatorPrefHelper.PREF_IGNORELIST_BACKUP.put(null);
+            resetignorelistButton = new SideButton(new AbstractAction() {
+                int reset;
+                {
+                    toggle();
+                }
+
+                public void toggle() {
+                    this.setEnabled(true);
+                    if (!OsmValidator.getIgnoredErrors().isEmpty()) {
+                        putValue(NAME, tr("Clear Ignore"));
+                        putValue(SHORT_DESCRIPTION, tr("Clear ignore list"));
+                        new ImageProvider("dialogs", "fix").getResource().attachImageIcon(this, true);
+                        reset = 1;
+                    } else {
+                        List<String> ignoredErrors = ValidatorPrefHelper.PREF_IGNORELIST_BACKUP.get();
+                        if (!ignoredErrors.isEmpty()) {
+                            putValue(NAME, tr("Restore Ignore"));
+                            putValue(SHORT_DESCRIPTION, tr("Restore ignore list"));
+                            new ImageProvider("copy").getResource().attachImageIcon(this, true);
+                            reset = 2;
+                        } else {
+                            putValue(NAME, tr("Ignore list modification"));
+                            putValue(SHORT_DESCRIPTION, tr("Clear/Restore/Save the ignore list, depending upon various conditions"));
+                            new ImageProvider("dialogs", "validator").getResource().attachImageIcon(this, true);
+                            this.setEnabled(false);
+                        }
+                    }
+                }
+
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    int doToggle = JOptionPane.NO_OPTION;
+                    if (e != null) {
+                        if (reset == 1 || reset == 2) doToggle = rerunValidatorPrompt();
+                        if (reset == 1 && (doToggle == JOptionPane.YES_OPTION || doToggle == JOptionPane.NO_OPTION)) {
+                            OsmValidator.resetErrorList();
+                        } else if (reset == 2 && (doToggle == JOptionPane.YES_OPTION || doToggle == JOptionPane.NO_OPTION)) {
+                            OsmValidator.restoreErrorList();
+                        }
+                    }
+                    if (doToggle == JOptionPane.YES_OPTION || doToggle == JOptionPane.NO_OPTION) toggle();
+                }
+            });
+            buttons.add(resetignorelistButton);
         } else {
             ignoreButton = null;
+            resetignorelistButton = null;
         }
+
         createLayout(tree, true, buttons);
     }
 
@@ -280 +332 @@
         if (changed.get()) {
             tree.resetErrors();
             OsmValidator.saveIgnoredErrors();
+            if (resetignorelistButton != null) {
+                resetignorelistButton.getAction().actionPerformed(null);
+            }
             invalidateValidatorLayers();
         }
     }
 
     /**
+     * Prompt to rerun the validator when the ignore list changes
+     * @return {@code JOptionPane.YES_OPTION}, {@code JOptionPane.NO_OPTION},
+     *  or {@code JOptionPane.CANCEL_OPTION}
+     */
+    public int rerunValidatorPrompt() {
+        MapFrame map = MainApplication.getMap();
+        List<TestError> errors = map.validatorDialog.tree.getErrors();
+        if (!validateAction.isEnabled() || errors == null || errors.isEmpty()) return JOptionPane.NO_OPTION;
+        final int answer = ConditionalOptionPaneUtil.showOptionDialog(
+                "rerun_validation_when_ignorelist_changed",
+                MainApplication.getMainFrame(),
+                "<hmtl><h3>" + tr("Should the validation be rerun?") + "</h3></html>",
+                tr("Ignored error filter changed"),
+                JOptionPane.YES_NO_CANCEL_OPTION,
+                JOptionPane.QUESTION_MESSAGE,
+                null,
+                null);
+        if (answer == JOptionPane.YES_OPTION) {
+            validateAction.doValidate(true);
+        }
+        return answer;
+    }
+
+    /**
      * Sets the selection of the map to the current selected items.
      */
-    @SuppressWarnings("unchecked")
     private void setSelectedItems() {
         DataSet ds = MainApplication.getLayerManager().getActiveDataSet();
         if (tree == null || ds == null)