Changeset 15978 in josm


Ignore:
Timestamp:
2020-03-01T21:33:56+01:00 (2 years ago)
Author:
simon04
Message:

fix #18140 - Switch to OpeningHoursParser

Location:
trunk
Files:
1 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/CONTRIBUTION

    r15945 r15978  
    6969and licensed with GPL / classpath exception.
    7070
    71 The opening hour validation uses code from opening_hour.js
    72 (https://github.com/ypid/opening_hours.js) which is licensed
    73 with the New (2-clause) BSD license.
     71The opening hour validation uses OpeningHoursParser
     72(https://github.com/simonpoole/OpeningHoursParser) which is licensed
     73with MIT.
    7474
    7575The XZ code (https://tukaani.org/xz/java.html)
  • trunk/README

    r15033 r15978  
    6868      - *.cfg               files designed for the old tagchecker, still in use
    6969      - *.mapcss            default validation rules for the MapCSS-based tagchecker
    70       - opening_hours.js    Javascript code to validate opening hours tag
    71                             (external library, see https://github.com/opening-hours/opening_hours.js)
    7270    - boundaries.osm        OSM file containing boundary data for the states of the earth, including
    7371                            data for right and left-hand traffic
     
    211209    src/org/tukaani
    212210    -> https://tukaani.org/xz/java.html
     211* OpeningHoursParser (MIT license)
     212    -> https://github.com/simonpoole/OpeningHoursParser
  • trunk/data/defaultpresets.xml

    r15955 r15978  
    136136    </chunk>
    137137    <chunk id="oh">
    138         <combo key="opening_hours" text="Opening Hours" delimiter="|" values="24/7|08:30-12:30,15:30-20:00|Sa-Su 00:00-24:00|Mo-Su 09:00-21:00|Mo-Sa 08:00-18:00|Mo-Fr 09:00-17:00|Mo-Fr 08:30-20:00; Sa,Su 08:00-15:00; PH off|Mo-Fr 08:30-20:00, Tu-Su 08:00-15:00; Sa 08:00-12:00|Mo-Su 08:00-18:00; Apr 10-15 off; Jun 08:00-14:00; Aug off; Dec 25 off|sunrise-sunset|Su 10:00+|week 01-53/2 Fr 09:00-12:00; week 02-52/2 We 09:00-12:00" values_no_i18n="true" />
     138        <combo key="opening_hours" text="Opening Hours" delimiter="|" values="24/7|08:30-12:30,15:30-20:00|Sa-Su 00:00-24:00|Mo-Su 09:00-21:00|Mo-Sa 08:00-18:00|Mo-Fr 09:00-17:00|Mo-Fr 08:30-20:00; Sa,Su 08:00-15:00; PH off|Mo-Fr 08:30-20:00; Tu-Su 08:00-15:00; Sa 08:00-12:00|Mo-Su 08:00-18:00; Apr 10-15 off; Jun 08:00-14:00; Aug off; Dec 25 off|sunrise-sunset|Su 10:00+|week 01-53/2 Fr 09:00-12:00; week 02-52/2 We 09:00-12:00" values_no_i18n="true" />
    139139    </chunk>
    140140    <chunk id="wheelchair">
     
    30083008            <combo key="reservation" text="Reservation" values="yes,no,required,recommended,members_only" />
    30093009            <reference ref="oh" />
    3010             <combo key="opening_hours:kitchen" text="Kitchen Opening Hours" delimiter="|" values="24/7|08:30-12:30,15:30-20:00|Sa-Su 00:00-24:00|Mo-Su 09:00-21:00|Mo-Sa 08:00-18:00|Mo-Fr 09:00-17:00|Mo-Fr 08:30-20:00; Sa,Su 08:00-15:00; PH off|Mo-Fr 08:30-20:00, Tu-Su 08:00-15:00; Sa 08:00-12:00|Mo-Su 08:00-18:00; Apr 10-15 off; Jun 08:00-14:00; Aug off; Dec 25 off|sunrise-sunset|Su 10:00+|week 01-53/2 Fr 09:00-12:00; week 02-52/2 We 09:00-12:00" values_no_i18n="true" />
     3010            <combo key="opening_hours:kitchen" text="Kitchen Opening Hours" delimiter="|" values="24/7|08:30-12:30,15:30-20:00|Sa-Su 00:00-24:00|Mo-Su 09:00-21:00|Mo-Sa 08:00-18:00|Mo-Fr 09:00-17:00|Mo-Fr 08:30-20:00; Sa,Su 08:00-15:00; PH off|Mo-Fr 08:30-20:00; Tu-Su 08:00-15:00; Sa 08:00-12:00|Mo-Su 08:00-18:00; Apr 10-15 off; Jun 08:00-14:00; Aug off; Dec 25 off|sunrise-sunset|Su 10:00+|week 01-53/2 Fr 09:00-12:00; week 02-52/2 We 09:00-12:00" values_no_i18n="true" />
    30113011            <reference ref="wheelchair" />
    30123012            <combo key="stars" text="Stars" values="1,2,3,4,5,6,7" />
  • trunk/ivy.xml

    r15977 r15978  
    1717    </configurations>
    1818    <dependencies>
     19        <dependency org="ch.poole" name="OpeningHoursParser" rev="0.21.0"/>
    1920    </dependencies>
    2021</ivy-module>
  • trunk/src/org/openstreetmap/josm/data/validation/tests/ConditionalKeys.java

    r15743 r15978  
    99import java.util.HashSet;
    1010import java.util.List;
     11import java.util.Locale;
    1112import java.util.Set;
    1213import java.util.regex.Matcher;
     
    1718import org.openstreetmap.josm.data.validation.Test;
    1819import org.openstreetmap.josm.data.validation.TestError;
    19 import org.openstreetmap.josm.tools.LanguageInfo;
    2020import org.openstreetmap.josm.tools.Logging;
    2121import org.openstreetmap.josm.tools.SubclassFilteredCollection;
     
    205205                    if (condition.matches(".*[0-9]:[0-9]{2}.*")) {
    206206                        final List<OpeningHourTest.OpeningHoursTestError> errors = openingHourTest.checkOpeningHourSyntax(
    207                                 "", condition, OpeningHourTest.CheckMode.TIME_RANGE, true, LanguageInfo.getJOSMLocaleCode());
     207                                "", condition, true, Locale.getDefault());
    208208                        if (!errors.isEmpty()) {
    209209                            return errors.get(0).getMessage();
  • trunk/src/org/openstreetmap/josm/data/validation/tests/OpeningHourTest.java

    r15815 r15978  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import java.io.Reader;
    7 import java.util.ArrayList;
    8 import java.util.Arrays;
     6import java.io.StringReader;
    97import java.util.Collections;
    108import java.util.List;
     9import java.util.Locale;
     10import java.util.Objects;
    1111
    12 import javax.script.Invocable;
    13 import javax.script.ScriptEngine;
    14 import javax.script.ScriptException;
    15 import javax.swing.JOptionPane;
    16 
     12import ch.poole.openinghoursparser.OpeningHoursParser;
     13import ch.poole.openinghoursparser.ParseException;
     14import ch.poole.openinghoursparser.Rule;
     15import ch.poole.openinghoursparser.Util;
    1716import org.openstreetmap.josm.command.ChangePropertyCommand;
    1817import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    2019import org.openstreetmap.josm.data.validation.Test.TagTest;
    2120import org.openstreetmap.josm.data.validation.TestError;
    22 import org.openstreetmap.josm.gui.Notification;
    23 import org.openstreetmap.josm.gui.util.GuiHelper;
    24 import org.openstreetmap.josm.io.CachedFile;
    25 import org.openstreetmap.josm.tools.LanguageInfo;
    26 import org.openstreetmap.josm.tools.Logging;
    27 import org.openstreetmap.josm.tools.Utils;
    2821
    2922/**
    3023 * Tests the correct usage of the opening hour syntax of the tags
    3124 * {@code opening_hours}, {@code collection_times}, {@code service_times} according to
    32  * <a href="https://github.com/ypid/opening_hours.js">opening_hours.js</a>.
     25 * <a href="https://github.com/simonpoole/OpeningHoursParser">OpeningHoursParser</a>.
    3326 *
    34  * @since 6370
     27 * @since 6370 (using opening_hours.js), 15978 (using OpeningHoursParser)
    3528 */
    3629public class OpeningHourTest extends TagTest {
    37 
    38     /**
    39      * Javascript engine
    40      */
    41     public static final ScriptEngine ENGINE = Utils.getJavaScriptEngine();
    4230
    4331    /**
     
    4735        super(tr("Opening hours syntax"),
    4836                tr("This test checks the correct usage of the opening hours syntax."));
    49     }
    50 
    51     @Override
    52     public void initialize() throws Exception {
    53         super.initialize();
    54         if (ENGINE != null) {
    55             try (CachedFile cf = new CachedFile("resource://data/validator/opening_hours.js");
    56                  Reader reader = cf.getContentReader()) {
    57                 ENGINE.eval("var console={};console.debug=print;console.log=print;console.warn=print;console.error=print;");
    58                 ENGINE.eval(reader);
    59                 // fake country/state to not get errors on holidays
    60                 ENGINE.eval("var nominatimJSON = {address: {country_code: 'xa'}};");
    61                 ENGINE.eval(
    62                         "var oh = function (value, tag_key, mode, locale) {" +
    63                         " try {" +
    64                         "    var conf = {tag_key: tag_key, locale: locale, additional_rule_separator: false};" +
    65                         "    if (mode > -1) {" +
    66                         "      conf.mode = mode;" +
    67                         "    }" +
    68                         "    var r = new opening_hours(value, nominatimJSON, conf);" +
    69                         "    r.getErrors = function() {return [];};" +
    70                         "    return r;" +
    71                         "  } catch (err) {" +
    72                         "    return {" +
    73                         "      prettifyValue: function() {return null;}," +
    74                         "      getWarnings: function() {return [];}," +
    75                         "      getErrors: function() {return [err.toString()]}" +
    76                         "    };" +
    77                         "  }" +
    78                         "};");
    79             }
    80         } else {
    81             Logging.warn("Unable to initialize OpeningHourTest because no JavaScript engine has been found");
    82         }
    8337    }
    8438
     
    10458
    10559    /**
    106      * Parses the opening hour syntax of the {@code value} given according to
    107      * <a href="https://github.com/ypid/opening_hours.js">opening_hours.js</a> and returns an object on which
    108      * methods can be called to extract information.
    109      * @param value the opening hour value to be checked
    110      * @param tagKey the OSM key (should be "opening_hours", "collection_times" or "service_times")
    111      * @param mode whether to validate {@code value} as a time range, or points in time, or both. Can be null
    112      * @param locale the locale code used for localizing messages
    113      * @return The value returned by the underlying method. Usually a {@code jdk.nashorn.api.scripting.ScriptObjectMirror}
    114      * @throws ScriptException if an error occurs during invocation of the underlying method
    115      * @throws NoSuchMethodException if underlying method with given name or matching argument types cannot be found
    116      * @since 13147
    117      */
    118     public Object parse(String value, String tagKey, CheckMode mode, String locale) throws ScriptException, NoSuchMethodException {
    119         return ((Invocable) ENGINE).invokeFunction("oh", value, tagKey, mode != null ? mode.code : -1, locale);
    120     }
    121 
    122     @SuppressWarnings("unchecked")
    123     protected List<Object> getList(Object obj) throws ScriptException, NoSuchMethodException {
    124         if (obj == null || "".equals(obj)) {
    125             return Arrays.asList();
    126         } else if (obj instanceof String) {
    127             final Object[] strings = ((String) obj).split("\\\\n");
    128             return Arrays.asList(strings);
    129         } else if (obj instanceof List) {
    130             return (List<Object>) obj;
    131         } else {
    132             // recursively call getList() with argument converted to newline-separated string
    133             return getList(((Invocable) ENGINE).invokeMethod(obj, "join", "\\n"));
    134         }
    135     }
    136 
    137     /**
    13860     * An error concerning invalid syntax for an "opening_hours"-like tag.
    13961     */
     
    14466
    14567        /**
    146          * Constructs a new {@code OpeningHoursTestError} with a known pretiffied value.
     68         * Constructs a new {@code OpeningHoursTestError} with a known prettified value.
    14769         * @param message The error message
    14870         * @param severity The error severity
     
    203125
    204126    /**
    205      * Checks for a correct usage of the opening hour syntax of the {@code value} given according to
    206      * <a href="https://github.com/ypid/opening_hours.js">opening_hours.js</a> and returns a list containing
    207      * validation errors or an empty list. Null values result in an empty list.
     127     * Checks for a correct usage of the opening hour syntax of the {@code value} given,
     128     * and returns a list containing validation errors or an empty list. Null values result in an empty list.
    208129     * @param key the OSM key (should be "opening_hours", "collection_times" or "service_times"). Used in error message
    209130     * @param value the opening hour value to be checked.
     
    211132     */
    212133    public List<OpeningHoursTestError> checkOpeningHourSyntax(final String key, final String value) {
    213         return checkOpeningHourSyntax(key, value, null, false, LanguageInfo.getJOSMLocaleCode());
     134        return checkOpeningHourSyntax(key, value, false, Locale.getDefault());
    214135    }
    215136
    216137    /**
    217      * Checks for a correct usage of the opening hour syntax of the {@code value} given according to
    218      * <a href="https://github.com/ypid/opening_hours.js">opening_hours.js</a> and returns a list containing
    219      * validation errors or an empty list. Null values result in an empty list.
     138     * Checks for a correct usage of the opening hour syntax of the {@code value} given,
     139     * and returns a list containing validation errors or an empty list. Null values result in an empty list.
    220140     * @param key the OSM key (should be "opening_hours", "collection_times" or "service_times").
    221141     * @param value the opening hour value to be checked.
    222      * @param mode whether to validate {@code value} as a time range, or points in time, or both. Can be null
    223142     * @param ignoreOtherSeverity whether to ignore errors with {@link Severity#OTHER}.
    224143     * @param locale the locale code used for localizing messages
    225144     * @return a list of {@link TestError} or an empty list
    226145     */
    227     public List<OpeningHoursTestError> checkOpeningHourSyntax(final String key, final String value, CheckMode mode,
    228             boolean ignoreOtherSeverity, String locale) {
    229         if (ENGINE == null || value == null || value.isEmpty()) {
     146    public List<OpeningHoursTestError> checkOpeningHourSyntax(final String key, final String value, boolean ignoreOtherSeverity, Locale locale) {
     147        if (value == null || value.isEmpty()) {
    230148            return Collections.emptyList();
    231149        }
    232         final List<OpeningHoursTestError> errors = new ArrayList<>();
     150
     151        ch.poole.openinghoursparser.I18n.setLocale(locale);
     152        String prettifiedValue = null;
    233153        try {
    234             final Object r = parse(value, key, mode, locale);
    235             String prettifiedValue = null;
    236             try {
    237                 prettifiedValue = getOpeningHoursPrettifiedValues(r);
    238             } catch (ScriptException | NoSuchMethodException e) {
    239                 Logging.warn(e);
     154            final List<Rule> rules = new OpeningHoursParser(new StringReader(value)).rules(false);
     155            prettifiedValue = Util.rulesToOpeningHoursString(rules);
     156            if (!Objects.equals(value, prettifiedValue)) {
     157                // parse again in strict mode for detailed message
     158                new OpeningHoursParser(new StringReader(value)).rules(true);
    240159            }
    241             for (final Object i : getOpeningHoursErrors(r)) {
    242                 errors.add(new OpeningHoursTestError(getErrorMessage(key, i), Severity.ERROR, prettifiedValue));
    243             }
    244             for (final Object i : getOpeningHoursWarnings(r)) {
    245                 errors.add(new OpeningHoursTestError(getErrorMessage(key, i), Severity.WARNING, prettifiedValue));
    246             }
    247             if (!ignoreOtherSeverity && errors.isEmpty() && prettifiedValue != null && !value.equals(prettifiedValue)) {
    248                 errors.add(new OpeningHoursTestError(tr("opening_hours value can be prettified"), Severity.OTHER, prettifiedValue));
    249             }
    250         } catch (ScriptException | NoSuchMethodException ex) {
    251             Logging.error(ex);
    252             GuiHelper.runInEDT(() -> new Notification(Utils.getRootCause(ex).getMessage()).setIcon(JOptionPane.ERROR_MESSAGE).show());
     160        } catch (ParseException e) {
     161            return Collections.singletonList(new OpeningHoursTestError(e.getMessage(), Severity.WARNING, prettifiedValue));
    253162        }
    254         return errors;
    255     }
    256163
    257     /**
    258      * Returns the prettified value returned by the opening hours parser.
    259      * @param r result of {@link #parse}
    260      * @return the prettified value returned by the opening hours parser
    261      * @throws NoSuchMethodException if method "prettifyValue" or matching argument types cannot be found
    262      * @throws ScriptException if an error occurs during invocation of the JavaScript method
    263      * @since 13296
    264      */
    265     public final String getOpeningHoursPrettifiedValues(Object r) throws NoSuchMethodException, ScriptException {
    266         return (String) ((Invocable) ENGINE).invokeMethod(r, "prettifyValue");
    267     }
    268 
    269     /**
    270      * Returns the list of errors returned by the opening hours parser.
    271      * @param r result of {@link #parse}
    272      * @return the list of errors returned by the opening hours parser
    273      * @throws NoSuchMethodException if method "getErrors" or matching argument types cannot be found
    274      * @throws ScriptException if an error occurs during invocation of the JavaScript method
    275      * @since 13296
    276      */
    277     public final List<Object> getOpeningHoursErrors(Object r) throws NoSuchMethodException, ScriptException {
    278         return getList(((Invocable) ENGINE).invokeMethod(r, "getErrors"));
    279     }
    280 
    281     /**
    282      * Returns the list of warnings returned by the opening hours parser.
    283      * @param r result of {@link #parse}
    284      * @return the list of warnings returned by the opening hours parser
    285      * @throws NoSuchMethodException if method "getWarnings" or matching argument types cannot be found
    286      * @throws ScriptException if an error occurs during invocation of the JavaScript method
    287      * @since 13296
    288      */
    289     public final List<Object> getOpeningHoursWarnings(Object r) throws NoSuchMethodException, ScriptException {
    290         return getList(((Invocable) ENGINE).invokeMethod(r, "getWarnings"));
    291     }
    292 
    293     /**
    294      * Translates and shortens the error/warning message.
    295      * @param o error/warning message returned by {@link #getOpeningHoursErrors} or {@link #getOpeningHoursWarnings}
    296      * @return translated/shortened error/warning message
    297      * @since 13298
    298      */
    299     public static String getErrorMessage(Object o) {
    300         return o.toString().trim()
    301         .replace("Unexpected token:", tr("Unexpected token:"))
    302         .replace("Unexpected token (school holiday parser):", tr("Unexpected token (school holiday parser):"))
    303         .replace("Unexpected token in number range:", tr("Unexpected token in number range:"))
    304         .replace("Unexpected token in week range:", tr("Unexpected token in week range:"))
    305         .replace("Unexpected token in weekday range:", tr("Unexpected token in weekday range:"))
    306         .replace("Unexpected token in month range:", tr("Unexpected token in month range:"))
    307         .replace("Unexpected token in year range:", tr("Unexpected token in year range:"))
    308         .replace("This means that the syntax is not valid at that point or it is currently not supported.", tr("Invalid/unsupported syntax."));
    309     }
    310 
    311     /**
    312      * Translates and shortens the error/warning message.
    313      * @param key OSM key
    314      * @param o error/warning message returned by {@link #getOpeningHoursErrors} or {@link #getOpeningHoursWarnings}
    315      * @return translated/shortened error/warning message
    316      */
    317     static String getErrorMessage(String key, Object o) {
    318         return key + " - " + getErrorMessage(o);
     164        if (ignoreOtherSeverity || Objects.equals(value, prettifiedValue)) {
     165            return Collections.emptyList();
     166        } else {
     167            return Collections.singletonList(
     168                    new OpeningHoursTestError(tr("{0} value can be prettified", key), Severity.OTHER, prettifiedValue));
     169        }
    319170    }
    320171
  • trunk/test/unit/org/openstreetmap/josm/data/validation/tests/OpeningHourTestTest.java

    r15815 r15978  
    66import static org.hamcrest.CoreMatchers.not;
    77import static org.junit.Assert.assertEquals;
    8 import static org.junit.Assert.assertFalse;
    98import static org.junit.Assert.assertThat;
    109import static org.junit.Assert.assertTrue;
     
    1413import java.util.LinkedHashSet;
    1514import java.util.List;
     15import java.util.Locale;
    1616import java.util.Set;
    1717
     
    6666        assertThat(openingHourTest.checkOpeningHourSyntax(key, "09:00-21:00"), isEmpty());
    6767        assertThat(openingHourTest.checkOpeningHourSyntax(key, "Su-Th sunset-24:00,04:00-sunrise; Fr-Sa sunset-sunrise"), isEmpty());
    68         assertThat(openingHourTest.checkOpeningHourSyntax(key, "Su-Th sunset-24:00, 04:00-sunrise; Fr-Sa sunset-sunrise"), hasSize(1));
    69         assertEquals(Severity.OTHER, openingHourTest.checkOpeningHourSyntax(
    70                 key, "Su-Th sunset-24:00, 04:00-sunrise; Fr-Sa sunset-sunrise").get(0).getSeverity());
    71         assertEquals("Su-Th sunset-24:00,04:00-sunrise; Fr-Sa sunset-sunrise", openingHourTest.checkOpeningHourSyntax(
    72                 key, "Su-Th sunset-24:00, 04:00-sunrise; Fr-Sa sunset-sunrise").get(0).getPrettifiedValue());
    7368    }
    7469
     
    7873    @Test
    7974    public void testI18n() {
    80         assertTrue(openingHourTest.checkOpeningHourSyntax("opening_hours", ".", null, false, "de")
    81                 .get(0).toString().contains("Unerwartetes Zeichen"));
    82         assertFalse(openingHourTest.checkOpeningHourSyntax("opening_hours", ".", null, false, "en")
    83                 .get(0).toString().contains("Unerwartetes Zeichen"));
     75        final String key = "opening_hours";
     76        String value = ".";
     77        assertEquals("Vorgefunden wurde:  \".\" \". \" in Zeile 0, Zeichen 0\nErwartet wurde: <EOF> => null",
     78                openingHourTest.checkOpeningHourSyntax(key, value, false, Locale.GERMAN).get(0).toString());
     79        assertEquals("Encountered:  \".\" \". \" at line 0, column 0\nWas expecting: <EOF> => null",
     80                openingHourTest.checkOpeningHourSyntax(key, value, false, Locale.ENGLISH).get(0).toString());
     81        value = "Mon-Thu 12-18";
     82        assertEquals("Wochentag mit 3 Buchstaben in Zeile 1, Zeichen 4 => Mo-Th 12:00-18:00",
     83                openingHourTest.checkOpeningHourSyntax(key, value, false, Locale.GERMAN).get(0).toString());
     84        assertEquals("Three character weekday at line 1, column 4 => Mo-Th 12:00-18:00",
     85                openingHourTest.checkOpeningHourSyntax(key, value, false, Locale.ENGLISH).get(0).toString());
    8486    }
    8587
     
    9193        final String key = "opening_hours";
    9294        final List<OpeningHourTest.OpeningHoursTestError> errors = openingHourTest.checkOpeningHourSyntax(key, "Mo-Tue");
    93         assertThat(errors, hasSize(2));
    94         assertEquals(key + " - Mo-Tue <--- (Please use the English abbreviation \"Tu\" for \"tue\".)", errors.get(0).getMessage());
     95        assertThat(errors, hasSize(1));
     96        assertEquals("Mo-Tu", errors.get(0).getPrettifiedValue());
     97        assertEquals("Three character weekday at line 1, column 6", errors.get(0).getMessage());
    9598        assertEquals(Severity.WARNING, errors.get(0).getSeverity());
    96         assertEquals(key +
    97                 " - Mo-Tue <--- (This rule is not very explicit because there is no time selector being used."+
    98                 " A time selector is the part specifying hours when the object is opened, for example \"10:00-19:00\"."+
    99                 " Please add a time selector to this rule or use a comment to make it more explicit.)", errors.get(1).getMessage());
    100         assertEquals(Severity.WARNING, errors.get(1).getSeverity());
    10199    }
    102100
     
    108106        final String key = "opening_hours";
    109107        final List<OpeningHourTest.OpeningHoursTestError> errors = openingHourTest.checkOpeningHourSyntax(key, "Sa-Su 10.00-20.00");
    110         assertThat(errors, hasSize(2));
    111         assertEquals(key + " - Sa-Su 10. <--- (Please use \":\" as hour/minute-separator)", errors.get(0).getMessage());
     108        assertThat(errors, hasSize(1));
     109        assertEquals("Sa-Su 10:00-20:00", errors.get(0).getPrettifiedValue());
     110        assertEquals("Invalid minutes at line 1, column 12", errors.get(0).getMessage());
    112111        assertEquals(Severity.WARNING, errors.get(0).getSeverity());
    113         assertEquals("Sa-Su 10:00-20:00", errors.get(0).getPrettifiedValue());
    114         assertEquals(key + " - Sa-Su 10.00-20. <--- (Please use \":\" as hour/minute-separator)", errors.get(1).getMessage());
    115         assertEquals(Severity.WARNING, errors.get(1).getSeverity());
    116112    }
    117113
     
    123119        assertThat(openingHourTest.checkOpeningHourSyntax(null, null), isEmpty());
    124120        assertThat(openingHourTest.checkOpeningHourSyntax(null, ""), isEmpty());
    125         assertEquals("opening_hours - The value contains nothing meaningful which can be parsed.",
     121        assertEquals("opening_hours value can be prettified",
    126122                openingHourTest.checkOpeningHourSyntax("opening_hours", " ").get(0).getMessage());
    127         assertEquals("null - The optional_conf_parm[\"tag_key\"] parameter is of unknown type. Given object, expected string.",
     123        assertEquals("null value can be prettified",
    128124                openingHourTest.checkOpeningHourSyntax(null, " ").get(0).getMessage());
    129125    }
     
    136132        final String key = "opening_hours";
    137133        assertThat(openingHourTest.checkOpeningHourSyntax(key, "badtext"), hasSize(1));
    138         assertEquals(key + " - ba <--- (Unexpected token: \"b\" Invalid/unsupported syntax.)",
    139                 openingHourTest.checkOpeningHourSyntax(key, "badtext").get(0).getMessage());
     134        assertEquals("Encountered:  <UNEXPECTED_CHAR> \"b \" at line 0, column 0\nWas expecting: <EOF>",
     135                openingHourTest.checkOpeningHourSyntax(key, "badtext").get(0).getMessage().trim());
    140136        assertThat(openingHourTest.checkOpeningHourSyntax(key, "5.00 p.m-11.00 p.m"), hasSize(1));
    141         assertEquals(key + " - 5.00 p <--- (hyphen (-) or open end (+) in time range expected. "
    142                 + "For working with points in time, the mode for opening_hours.js has to be altered. Maybe wrong tag?)",
     137        assertEquals("Encountered:  <UNEXPECTED_CHAR> \"p \" at line 1, column 2\nWas expecting: <EOF>",
    143138                openingHourTest.checkOpeningHourSyntax(key, "5.00 p.m-11.00 p.m").get(0).getMessage());
    144139    }
     
    159154    public void testCheckOpeningHourSyntax7() {
    160155        final String key = "opening_hours";
     156        assertThat(openingHourTest.checkOpeningHourSyntax(key, "9:00-18:00", true, Locale.getDefault()), isEmpty());
    161157        assertThat(openingHourTest.checkOpeningHourSyntax(key, "9:00-18:00"), hasSize(1));
    162158        assertEquals(Severity.OTHER, openingHourTest.checkOpeningHourSyntax(key, "9:00-18:00").get(0).getSeverity());
     
    171167        final String key = "opening_hours";
    172168        assertEquals(Severity.WARNING, openingHourTest.checkOpeningHourSyntax(key, "Mo,Tu 04-17").get(0).getSeverity());
    173         assertEquals(key + " - Mo,Tu 04-17 <--- (Time range without minutes specified. "
    174                 + "Not very explicit! Please use this syntax instead \"04:00-17:00\".)",
     169        assertEquals("Hours without minutes",
    175170                openingHourTest.checkOpeningHourSyntax(key, "Mo,Tu 04-17").get(0).getMessage());
    176         assertEquals("Mo,Tu 04:00-17:00", openingHourTest.checkOpeningHourSyntax(key, "Mo,Tu 04-17").get(0).getPrettifiedValue());
    177171    }
    178172
     
    188182        assertThat(openingHourTest.checkOpeningHourSyntax(key, "Mo-Sa 09:00-18:00"), isEmpty());
    189183        assertThat(openingHourTest.checkOpeningHourSyntax(key, "Su 09:30; We 19:30"), isEmpty());
    190         assertThat(openingHourTest.checkOpeningHourSyntax(key, "Mo-Fr 00:00-00:30,04:00-00:30; Sa,Su,PH 00:00-24:00"), isEmpty());
     184        // assertThat(openingHourTest.checkOpeningHourSyntax(key, "Mo-Fr 00:00-00:30,04:00-00:30; Sa,Su,PH 00:00-24:00"), isEmpty());
    191185        assertThat(openingHourTest.checkOpeningHourSyntax(key, "Mo-Fr 0:00-0:30,4:00-00:30; Sa,Su,PH 0:00-24:00"), hasSize(1));
    192         assertEquals("Mo-Fr 00:00-00:30,04:00-00:30; Sa,Su,PH 00:00-24:00",
     186        assertEquals("Mo-Fr 00:00-00:30,04:00-00:30; PH,Sa,Su 00:00-24:00",
    193187                openingHourTest.checkOpeningHourSyntax(key, "Mo-Fr 0:00-0:30,4:00-00:30; Sa,Su,PH 0:00-24:00").get(0).getPrettifiedValue());
    194         assertEquals("Mo-Fr 00:00-00:30,04:00-00:30; Sa,Su,PH 00:00-24:00",
     188        assertEquals("Mo-Fr 00:00-00:30,04:00-00:30; PH,Sa,Su 00:00-24:00",
    195189                openingHourTest.checkOpeningHourSyntax(key, "Mo-Fr 0:00-0:30,4:00-00:30; Sa,Su,PH 0:00-24:00").get(0).getPrettifiedValue());
    196190    }
     
    233227        for (final Tag t : values) {
    234228            final List<OpeningHourTest.OpeningHoursTestError> errors = openingHourTest.checkOpeningHourSyntax(t.getKey(), t.getValue());
     229            if (!errors.isEmpty() && errors.get(0).getMessage().startsWith("Holiday after weekday")) {
     230                continue;
     231            }
    235232            assertThat(t + " is valid", errors, isEmpty());
    236233        }
Note: See TracChangeset for help on using the changeset viewer.