Changeset 14828 in josm

Timestamp:

2019-03-03T10:52:10+01:00 (5 years ago)

Author:

GerdP

Message:

fix #17268: There should be a method to clear ignored errors

patch clear_ignored_errors_v32.patch by taylor.smock adapted to r14827

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/preferences/sources/ValidatorPrefHelper.java (modified) (1 diff)
• data/validation/OsmValidator.java (modified) (8 diffs)
• gui/dialogs/ValidatorDialog.java (modified) (8 diffs)
• gui/dialogs/ValidatorListManagementDialog.java (added)

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

@@ -44 +44 @@
     /** 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 String PREF_IGNORELIST = PREFIX + ".ignorelist";
 
     /**

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

@@ -8 +8 @@
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -18 +17 @@
 import java.util.Collections;
 import java.util.EnumMap;
+import java.util.Enumeration;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.SortedMap;
 import java.util.TreeMap;
@@ -28 +30 @@
 
 import javax.swing.JOptionPane;
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeModel;
+import javax.swing.tree.TreeNode;
 
 import org.openstreetmap.josm.data.preferences.sources.ValidatorPrefHelper;
@@ -89 +95 @@
     private static double griddetail;
 
-    private static final Collection<String> ignoredErrors = new TreeSet<>();
-
+    private static final SortedMap<String, String> ignoredErrors = new TreeMap<>();
     /**
      * All registered tests
@@ -170 +175 @@
         checkValidatorDir();
         initializeGridDetail();
-        loadIgnoredErrors(); //FIXME: load only when needed
+        loadIgnoredErrors();
     }
 
@@ -205 +210 @@
         ignoredErrors.clear();
         if (ValidatorPrefHelper.PREF_USE_IGNORE.get()) {
+            Config.getPref().getListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST).forEach(ignoredErrors::putAll);
             Path path = Paths.get(getValidatorDir()).resolve("ignorederrors");
             try {
                 if (path.toFile().exists()) {
                     try {
-                        ignoredErrors.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
+                        TreeSet<String> treeSet = new TreeSet<>();
+                        treeSet.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
+                        treeSet.forEach(ignore -> ignoredErrors.putIfAbsent(ignore, ""));
+
+                        saveIgnoredErrors();
+                        Files.deleteIfExists(path);
+
                     } catch (FileNotFoundException e) {
                         Logging.debug(Logging.getErrorMessage(e));
@@ -229 +241 @@
      */
     public static void addIgnoredError(String s) {
-        ignoredErrors.add(s);
+        addIgnoredError(s, "");
+    }
+
+    /**
+     * Adds an ignored error
+     * @param s The ignore group / sub group name
+     * @param description What the error actually is
+     * @see TestError#getIgnoreGroup()
+     * @see TestError#getIgnoreSubGroup()
+     */
+    public static void addIgnoredError(String s, String description) {
+        if (description == null) description = "";
+        ignoredErrors.put(s, description);
+    }
+
+    /**
+     *  Make sure that we don't keep single entries for a "group ignore" or
+     *  multiple different entries for the single entries that are in the same group.
+     */
+    private static void cleanupIgnoredErrors() {
+        if (ignoredErrors.size() > 1) {
+            List<String> toRemove = new ArrayList<>();
+
+            Iterator<Entry<String, String>> iter = ignoredErrors.entrySet().iterator();
+            Entry<String, String> last = iter.next();
+            while (iter.hasNext()) {
+                Entry<String, String> entry = iter.next();
+                if (entry.getKey().startsWith(last.getKey())) {
+                    toRemove.add(entry.getKey());
+                } else {
+                    last = entry;
+                }
+            }
+            toRemove.forEach(ignoredErrors::remove);
+        }
+
+        Map<String, String> tmap = buildIgnore(buildJTreeList());
+        if (tmap != null && !tmap.isEmpty()) {
+            ignoredErrors.clear();
+            ignoredErrors.putAll(tmap);
+        }
     }
 
@@ -238 +290 @@
      */
     public static boolean hasIgnoredError(String s) {
-        return ignoredErrors.contains(s);
-    }
-
-    /**
-     * Saves the names of the ignored errors to a file
+        return ignoredErrors.containsKey(s);
+    }
+
+    /**
+     * Get the list of all ignored errors
+     * @return The <code>Collection&ltString&gt</code> of errors that are ignored
+     */
+    public static SortedMap<String, String> getIgnoredErrors() {
+        return ignoredErrors;
+    }
+
+    /**
+     * Build a JTree with a list
+     * @return &lttype&gtlist as a {@code JTree}
+     */
+    public static JTree buildJTreeList() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode(tr("Ignore list"));
+        for (Entry<String, String> e: ignoredErrors.entrySet()) {
+            String key = e.getKey();
+            String value = e.getValue();
+            ArrayList<String> ignoredWayList = new ArrayList<>();
+            String[] osmobjects = key.split(":(r|w|n)_");
+            for (int i = 1; i < osmobjects.length; i++) {
+                String osmid = osmobjects[i];
+                if (osmid.matches("^[0-9]+$")) {
+                    osmid = '_' + osmid;
+                    int index = key.indexOf(osmid);
+                    if (index < key.lastIndexOf(']')) continue;
+                    char type = key.charAt(index - 1);
+                    ignoredWayList.add(type + osmid);
+                }
+            }
+            for (String osmignore : ignoredWayList) {
+                key = key.replace(':' + osmignore, "");
+            }
+
+            DefaultMutableTreeNode trunk;
+            DefaultMutableTreeNode branch;
+
+            if (value != null && !value.isEmpty()) {
+                trunk = inTree(root, value);
+                branch = inTree(trunk, key);
+                trunk.add(branch);
+            } else {
+                trunk = inTree(root, key);
+                branch = trunk;
+            }
+            ignoredWayList.forEach(osmignore -> branch.add(new DefaultMutableTreeNode(osmignore)));
+
+            root.add(trunk);
+        }
+        return new JTree(root);
+    }
+
+    private static DefaultMutableTreeNode inTree(DefaultMutableTreeNode root, String name) {
+        @SuppressWarnings("unchecked")
+        Enumeration<TreeNode> trunks = root.children();
+        while (trunks.hasMoreElements()) {
+            TreeNode ttrunk = trunks.nextElement();
+            if (ttrunk instanceof DefaultMutableTreeNode) {
+                DefaultMutableTreeNode trunk = (DefaultMutableTreeNode) ttrunk;
+                if (name.equals(trunk.getUserObject())) {
+                    return trunk;
+                }
+            }
+        }
+        return new DefaultMutableTreeNode(name);
+    }
+
+    /**
+     * Build a {@code HashMap} from a tree of ignored errors
+     * @param tree The JTree of ignored errors
+     * @return A {@code HashMap} of the ignored errors for comparison
+     */
+    public static Map<String, String> buildIgnore(JTree tree) {
+        TreeModel model = tree.getModel();
+        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
+        return buildIgnore(model, root);
+    }
+
+    private static Map<String, String> buildIgnore(TreeModel model, DefaultMutableTreeNode node) {
+        HashMap<String, String> rHashMap = new HashMap<>();
+
+        String osmids = node.getUserObject().toString();
+        String description = "";
+
+        if (!model.getRoot().equals(node)) {
+            description = ((DefaultMutableTreeNode) node.getParent()).getUserObject().toString();
+        } else {
+            description = node.getUserObject().toString();
+        }
+        if (tr("Ignore list").equals(description)) description = "";
+        if (!osmids.matches("^[0-9]+(_.*|$)")) {
+            description = osmids;
+            osmids = "";
+        }
+
+
+        for (int i = 0; i < model.getChildCount(node); i++) {
+            DefaultMutableTreeNode child = (DefaultMutableTreeNode) model.getChild(node, i);
+            if (model.getChildCount(child) == 0) {
+                String ignoreName = child.getUserObject().toString();
+                if (ignoreName.matches("^(r|w|n)_.*")) {
+                    osmids += ":" + child.getUserObject().toString();
+                } else if (ignoreName.matches("^[0-9]+(_.*|)$")) {
+                    rHashMap.put(ignoreName, description);
+                }
+            } else {
+                rHashMap.putAll(buildIgnore(model, child));
+            }
+        }
+        if (!osmids.isEmpty() && osmids.indexOf(':') != 0) rHashMap.put(osmids, description);
+        return rHashMap;
+    }
+
+    /**
+     * Reset the error list by deleting {@code validator.ignorelist}
+     */
+    public static void resetErrorList() {
+        saveIgnoredErrors();
+        Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST, null);
+        OsmValidator.initialize();
+    }
+
+    /**
+     * Saves the names of the ignored errors to a preference
      */
     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<Map<String, String>> list = new ArrayList<>();
+        cleanupIgnoredErrors();
+        list.add(ignoredErrors);
+        int i = 0;
+        while (i < list.size()) {
+            if (list.get(i) == null || list.get(i).isEmpty()) {
+                list.remove(i);
+                continue;
+            }
+            i++;
+        }
+        if (list.isEmpty()) list = null;
+        Config.getPref().putListOfMaps(ValidatorPrefHelper.PREF_IGNORELIST, list);
     }
 

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

@@ -65 +65 @@
 import org.openstreetmap.josm.tools.InputMapUtils;
 import org.openstreetmap.josm.tools.JosmRuntimeException;
+import org.openstreetmap.josm.tools.Pair;
 import org.openstreetmap.josm.tools.Shortcut;
 import org.xml.sax.SAXException;
@@ -87 +88 @@
     /** The ignore button */
     private final SideButton ignoreButton;
+    /** The reset ignorelist button */
+    private final SideButton ignorelistManagement;
     /** The select button */
     private final SideButton selectButton;
@@ -160 +163 @@
             ignoreButton.setEnabled(false);
             buttons.add(ignoreButton);
+
+            ignorelistManagement = new SideButton(new AbstractAction() {
+                {
+                    putValue(NAME, tr("Manage Ignore"));
+                    putValue(SHORT_DESCRIPTION, tr("Manage the ignore list"));
+                    new ImageProvider("dialogs", "fix").getResource().attachImageIcon(this, true);
+                }
+
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    new ValidatorListManagementDialog("Ignore");
+                }
+            });
+            buttons.add(ignorelistManagement);
         } else {
             ignoreButton = null;
-        }
+            ignorelistManagement = null;
+        }
+
         createLayout(tree, true, buttons);
     }
@@ -169 +188 @@
      * The action to lookup the selection in the error tree.
      */
-     class LookupAction extends AbstractAction implements DataSelectionListener {
+    class LookupAction extends AbstractAction implements DataSelectionListener {
 
         LookupAction() {
@@ -274 +293 @@
             if (depth <= 1) {
                 if (!(mainNodeInfo instanceof TestError)) {
-                    Set<String> state = new HashSet<>();
+                    Set<Pair<String, String>> state = new HashSet<>();
                     // ask if the whole set should be ignored
                     if (asked == JOptionPane.DEFAULT_OPTION) {
@@ -286 +305 @@
                             err.setIgnored(true);
                             changed.set(true);
-                            state.add(depth == 1 ? err.getIgnoreSubGroup() : err.getIgnoreGroup());
+                            state.add(new Pair<>(node.getDepth() == 1 ? err.getIgnoreSubGroup() : err.getIgnoreGroup(), err.getMessage()));
                         }, processedNodes);
-                        for (String s : state) {
-                            OsmValidator.addIgnoredError(s);
+                        for (Pair<String, String> s : state) {
+                            OsmValidator.addIgnoredError(s.a, s.b);
                         }
                         continue;
@@ -300 +319 @@
                     String state = error.getIgnoreState();
                     if (state != null) {
-                        OsmValidator.addIgnoredError(state);
+                        OsmValidator.addIgnoredError(state, error.getMessage());
                     }
                     changed.set(true);
@@ -317 +336 @@
      * Sets the selection of the map to the current selected items.
      */
-    @SuppressWarnings("unchecked")
     private void setSelectedItems() {
         DataSet ds = MainApplication.getLayerManager().getActiveDataSet();