Ticket #21163: josm_21163.patch

src/org/openstreetmap/josm/data/validation/tests/ConditionalKeys.java

@@ -11 +11 @@
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.validation.Severity;
@@ -75 +76 @@
     }
 
     /**
+     * Check if the value is a valid restriction value
+     * @param part The value
+     * @param hasLanes key has :lanes included
+     * @return <code>true</code> for allowed restriction values
+     */
+    public static boolean isRestrictionValueLanes(String part, Boolean hasLanes) {
+        if (hasLanes) {
+            final Set<Boolean> check =
+                    Arrays.stream(part.split(tr("\\|")))
+                        .map(restrictionValue -> isRestrictionValue(restrictionValue))
+                        .collect(Collectors.toSet());
+            return check.contains(false) ? false : true;
+        }
+        else {
+            return isRestrictionValue(part);
+        }
+    }
+
+    /**
      * Checks if the key denotes a
      * <a href="http://wiki.openstreetmap.org/wiki/Key:access#Transport_mode_restrictions">transport access mode restriction</a>
      * @param part The key (or the restriction part of it, e.g. for lanes)
@@ -105 +125 @@
             return false;
         }
         final String[] parts = key.replace(":conditional", "").split(":", -1);
-        return isKeyValid3Parts(parts) || isKeyValid1Part(parts) || isKeyValid2Parts(parts);
+
+        /*
+         * Treat cases where "lanes" is used in keys. Simply remove them.
+         */
+        final String[] partsNoLanes = dealWithLanes(parts);
+
+        return isKeyValid3Parts(partsNoLanes) || isKeyValid1Part(partsNoLanes) || isKeyValid2Parts(partsNoLanes);
     }
 
+    /*
+     * This is not explicitly specified at <a href="https://wiki.openstreetmap.org/wiki/Conditional_restrictions#Tagging">conditional restrictions tagging</a>, but
+     *      it's saying below "A conditional Lanes restriction, evaluated per-lane, overrules a non-conditional lanes restriction"
+     * Remove from "parts" using ArrayList. This approach has the advantage that the rest of the checks do not have to be altered.
+     */
+    private static String[] dealWithLanes(String... parts) {
+        List<String> checkLanes = new ArrayList<>();
+        checkLanes.addAll(Arrays.asList(parts));
+        /* lanes may only be present/removed if other keys are used, too. Additionally,  they may only be used within the first two positions */
+        if(checkLanes.size() > 1 && checkLanes.indexOf("lanes") <= 1 ){
+            checkLanes.remove("lanes");
+        }
+        return checkLanes.toArray(new String[checkLanes.size()]);
+    }
+
     private static boolean isKeyValid3Parts(String... parts) {
         return parts.length == 3 && isRestrictionType(parts[0]) && isTransportationMode(parts[1]) && isDirection(parts[2]);
     }
@@ -195 +236 @@
         try {
             for (final ConditionalValue conditional : ConditionalValue.parse(value)) {
                 // validate restriction value
-                if (isTransportationMode(key.split(":", -1)[0]) && !isRestrictionValue(conditional.restrictionValue)) {
+                if (isTransportationMode(key.split(":", -1)[0]) && !isRestrictionValueLanes(conditional.restrictionValue, key.contains(tr(":lanes")))) {
                     return tr("{0} is not a valid restriction value", conditional.restrictionValue);
                 }
                 // validate opening hour if the value contains an hour (heuristic)

src/org/openstreetmap/josm/data/validation/tests/Lanes.java

@@ -40 +40 @@
         return value.isEmpty() ? 0 : value.replaceAll("[^|]", "").length() + 1;
     }
 
+    private int getLanesCountConditional(String value, Boolean isConditional, OsmPrimitive p) {
+        if (isConditional) {
+            // Also respect values like "yes|no|no @ (Mo-Fr 06:30-9:00); yes|no|no @ (Mo-Fr 17:30-19:00)"
+            final Set<Integer> allLanesCounts =
+                    Arrays.stream(value.split(";"))
+                        .map(removeConditional -> {return removeConditional.replaceAll("\\s*@\\s*\\(.*?\\)\\s*", "");})
+                        .map(singleValue -> getLanesCount(singleValue))
+                        .collect(Collectors.toSet());
+            if (allLanesCounts.size() > 1) {
+                // if not all numbers are the same
+                errors.add(TestError.builder(this, Severity.WARNING, 3100)
+                        .message(tr("Different lanes counts {0} within conditional value '{1}'", allLanesCounts.toString(), value))
+                        .primitives(p)
+                        .build());
+            }
+            return allLanesCounts.iterator().next();
+        }
+        else {
+            return getLanesCount(value);
+        }
+    }
+
     protected void checkNumberOfLanesByKey(final OsmPrimitive p, String lanesKey, String message) {
         final Set<Integer> lanesCount =
                 p.keys()
-                .filter(x -> x.endsWith(":" + lanesKey))
+                .filter(x -> x.endsWith(":" + lanesKey) || x.endsWith(":" + lanesKey + ":conditional"))
                 .filter(x -> !Arrays.asList(BLACKLIST).contains(x))
-                .map(key -> getLanesCount(p.get(key)))
+                .map(key -> getLanesCountConditional(p.get(key), key.endsWith(":conditional"), p))
                 .collect(Collectors.toSet());
 
         if (lanesCount.size() > 1) {