001// License: GPL. For details, see LICENSE file. 002package org.openstreetmap.josm.data.validation.tests; 003 004import static org.openstreetmap.josm.tools.I18n.tr; 005 006import java.util.ArrayList; 007import java.util.Arrays; 008import java.util.Collection; 009import java.util.HashSet; 010import java.util.List; 011import java.util.Set; 012import java.util.regex.Matcher; 013import java.util.regex.Pattern; 014 015import org.openstreetmap.josm.data.osm.OsmPrimitive; 016import org.openstreetmap.josm.data.validation.Severity; 017import org.openstreetmap.josm.data.validation.Test; 018import org.openstreetmap.josm.data.validation.TestError; 019import org.openstreetmap.josm.tools.LanguageInfo; 020import org.openstreetmap.josm.tools.Predicates; 021import org.openstreetmap.josm.tools.Utils; 022 023/** 024 * Checks for <a href="http://wiki.openstreetmap.org/wiki/Conditional_restrictions">conditional restrictions</a> 025 * @since 6605 026 */ 027public class ConditionalKeys extends Test.TagTest { 028 029 private final OpeningHourTest openingHourTest = new OpeningHourTest(); 030 private static final Set<String> RESTRICTION_TYPES = new HashSet<>(Arrays.asList("oneway", "toll", "noexit", "maxspeed", "minspeed", 031 "maxstay", "maxweight", "maxaxleload", "maxheight", "maxwidth", "maxlength", "overtaking", "maxgcweight", "maxgcweightrating", 032 "fee")); 033 private static final Set<String> RESTRICTION_VALUES = new HashSet<>(Arrays.asList("yes", "official", "designated", "destination", 034 "delivery", "permissive", "private", "agricultural", "forestry", "no")); 035 private static final Set<String> TRANSPORT_MODES = new HashSet<>(Arrays.asList("access", "foot", "ski", "inline_skates", "ice_skates", 036 "horse", "vehicle", "bicycle", "carriage", "trailer", "caravan", "motor_vehicle", "motorcycle", "moped", "mofa", 037 "motorcar", "motorhome", "psv", "bus", "taxi", "tourist_bus", "goods", "hgv", "agricultural", "atv", "snowmobile" 038 /*,"hov","emergency","hazmat","disabled"*/)); 039 040 /** 041 * Constructs a new {@code ConditionalKeys}. 042 */ 043 public ConditionalKeys() { 044 super(tr("Conditional Keys"), tr("Tests for the correct usage of ''*:conditional'' tags.")); 045 } 046 047 @Override 048 public void initialize() throws Exception { 049 super.initialize(); 050 openingHourTest.initialize(); 051 } 052 053 public static boolean isRestrictionType(String part) { 054 return RESTRICTION_TYPES.contains(part); 055 } 056 057 public static boolean isRestrictionValue(String part) { 058 return RESTRICTION_VALUES.contains(part); 059 } 060 061 public static boolean isTransportationMode(String part) { 062 // http://wiki.openstreetmap.org/wiki/Key:access#Transport_mode_restrictions 063 return TRANSPORT_MODES.contains(part); 064 } 065 066 public static boolean isDirection(String part) { 067 return "forward".equals(part) || "backward".equals(part); 068 } 069 070 public boolean isKeyValid(String key) { 071 // <restriction-type>[:<transportation mode>][:<direction>]:conditional 072 // -- or -- <transportation mode> [:<direction>]:conditional 073 if (!key.endsWith(":conditional")) { 074 return false; 075 } 076 final String[] parts = key.replaceAll(":conditional", "").split(":"); 077 return parts.length == 3 && isRestrictionType(parts[0]) && isTransportationMode(parts[1]) && isDirection(parts[2]) 078 || parts.length == 1 && (isRestrictionType(parts[0]) || isTransportationMode(parts[0])) 079 || parts.length == 2 && ( 080 isRestrictionType(parts[0]) && (isTransportationMode(parts[1]) || isDirection(parts[1])) 081 || isTransportationMode(parts[0]) && isDirection(parts[1])); 082 } 083 084 public boolean isValueValid(String key, String value) { 085 return validateValue(key, value) == null; 086 } 087 088 static class ConditionalParsingException extends RuntimeException { 089 ConditionalParsingException(String message) { 090 super(message); 091 } 092 } 093 094 public static class ConditionalValue { 095 public final String restrictionValue; 096 public final Collection<String> conditions; 097 098 public ConditionalValue(String restrictionValue, Collection<String> conditions) { 099 this.restrictionValue = restrictionValue; 100 this.conditions = conditions; 101 } 102 103 public static List<ConditionalValue> parse(String value) throws ConditionalParsingException { 104 // <restriction-value> @ <condition>[;<restriction-value> @ <condition>] 105 final List<ConditionalValue> r = new ArrayList<>(); 106 final String part = Pattern.compile("([^@\\p{Space}][^@]*?)" 107 + "\\s*@\\s*" + "(\\([^)\\p{Space}][^)]+?\\)|[^();\\p{Space}][^();]*?)\\s*").toString(); 108 final Matcher m = Pattern.compile('(' + part + ")(;\\s*" + part + ")*").matcher(value); 109 if (!m.matches()) { 110 throw new ConditionalParsingException(tr("Does not match pattern ''restriction value @ condition''")); 111 } else { 112 int i = 2; 113 while (i + 1 <= m.groupCount() && m.group(i + 1) != null) { 114 final String restrictionValue = m.group(i); 115 final String[] conditions = m.group(i + 1).replace("(", "").replace(")", "").split("\\s+(AND|and)\\s+"); 116 r.add(new ConditionalValue(restrictionValue, Arrays.asList(conditions))); 117 i += 3; 118 } 119 } 120 return r; 121 } 122 } 123 124 public String validateValue(String key, String value) { 125 try { 126 for (final ConditionalValue conditional : ConditionalValue.parse(value)) { 127 // validate restriction value 128 if (isTransportationMode(key.split(":")[0]) && !isRestrictionValue(conditional.restrictionValue)) { 129 return tr("{0} is not a valid restriction value", conditional.restrictionValue); 130 } 131 // validate opening hour if the value contains an hour (heuristic) 132 for (final String condition : conditional.conditions) { 133 if (condition.matches(".*[0-9]:[0-9]{2}.*")) { 134 final List<OpeningHourTest.OpeningHoursTestError> errors = openingHourTest.checkOpeningHourSyntax( 135 "", condition, OpeningHourTest.CheckMode.TIME_RANGE, true, LanguageInfo.getJOSMLocaleCode()); 136 if (!errors.isEmpty()) { 137 return errors.get(0).getMessage(); 138 } 139 } 140 } 141 } 142 } catch (ConditionalParsingException ex) { 143 return ex.getMessage(); 144 } 145 return null; 146 } 147 148 public List<TestError> validatePrimitive(OsmPrimitive p) { 149 final List<TestError> errors = new ArrayList<>(); 150 for (final String key : Utils.filter(p.keySet(), Predicates.stringMatchesPattern(Pattern.compile(".*:conditional(:.*)?$")))) { 151 if (!isKeyValid(key)) { 152 errors.add(new TestError(this, Severity.WARNING, tr("Wrong syntax in {0} key", key), 3201, p)); 153 continue; 154 } 155 final String value = p.get(key); 156 final String error = validateValue(key, value); 157 if (error != null) { 158 errors.add(new TestError(this, Severity.WARNING, tr("Error in {0} value: {1}", key, error), 3202, p)); 159 } 160 } 161 return errors; 162 } 163 164 @Override 165 public void check(OsmPrimitive p) { 166 errors.addAll(validatePrimitive(p)); 167 } 168}