How to parse Dates and Datetimes and Date*Ranges?

[spyse]

Hi folks,

I am trying to use dot-parse to write a small search engine. Following the example I wanted to add some special parsers.
For example a Digits-Range-Parser:

So my code currently looks like this:

Set<String> keywords = Set.of("AND", "OR", "NOT");

        // A search term is either quoted, or unquoted (but cannot be a keyword)
        Parser<SearchCriteria.Term> unquoted = word().suchThat(w -> !keywords.contains(w), "search term").map(SearchCriteria.Term::new);
        Parser<SearchCriteria.Term> quoted = Parser.quotedStringWithEscapes('"', chars(1)).map(SearchCriteria.Term::new);
        Parser<SearchCriteria.RangeDigits> rangeDigits = Parser.digits().notFollowedBy(":").atLeastOnceDelimitedBy("..").between("[", "]").map(list -> new SearchCriteria.RangeDigits(list.get(0), list.get(1)));

        // Leaf-level search term can be a quoted, unquoted term, or a sub-criteria inside parentheses.
        // They are then grouped by the boolean operators.
        parser = Parser.define(
                sub -> new OperatorTable<SearchCriteria>()
                        .prefix(word("NOT").thenReturn(SearchCriteria.Not::new), 30)
                        .leftAssociative(word("AND").thenReturn(SearchCriteria.And::new), 20)
                        .leftAssociative(word("OR").thenReturn(SearchCriteria.Or::new), 10)
                        .build(Parser.anyOf(rangeDigits, unquoted, quoted, sub.between("(", ")"))));

It works so far.
But now I wanted to add a special DateRange-Parser. But I cannot get my head around it.

Similar to rangeDigits I want the pattern for Dates to be recognized: [24.12.2025..31.12.2025]. But without a look ahead, I don't know how to parse a Date (24.12.2025) without running into the issue that the dots from [..] are mixed up in getting the first date.
Something like atMostDelimitedBy("..", 3)...

Any ideas?!

[fluentfuture]

IIUC, the digit range looks like this: [123..45] correct?

Then it shouldn't be ambiguous, simply use anyOf(digitRange, dateRange) because their grammars are not ambiguous.

Btw, I wouldn't use atLeastOnceDelimitedBy(). This seems easy enough?

Parser.sequence(
    digits().followedBy(".."),
    digits(),
    DigitsRange::new);

Similarly, something like this for date range:

Parser<Integer> digits(int n) {
  return Parser.digits().suchThat(s.length() == n, n + " digits").map(Integer::parseInt);
}

Parser<LocalDate> d = sequence(
    sequence(digits(2).followedBy("."), digits(2), DayAndMonth::new).followedBy("."),
    digits(4),
    (dm, y) -> new LocalDate(y, dm.month(), dm.day()));

Parser<DateRange> sequence( d.followedBy(".."), d, DateRange::new).between("[", "]");

[fluentfuture]

Or if you don't like the nested sequence() call, using atLeastOnceDelimitedBy() for the date range is an option too:

Parser<LocalDate> ld = Parser.digits()
    .atLeastOnceDelimitedBy(".")
    .suchThat(list ->
         list.size() == 3 && list.get(0).length() == 2 && list.get(1).length() == 2 && list.get(2).length() == 4,
        "dd.mm.yyyy")
    .map(list -> new LocalDate(Integer.parseInt(list.get(2)), Integer.parseInt(list.get(1)), Integer.parseInt(list.get(0))));
Parser<DateRange> dateRange = Parser.sequence(ld.followedBy(".."), ld, DateRange::new).between("[", "]");

[spyse]

Thank you. Gonna have a look into it with the updated sequence method with the next release!

[fluentfuture]

I just added a sequence() overload that will make the date parsing easier:

Parser<Integer> digits(int n) {
  return Parser.digits().suchThat(s.length() == n, n + " digits").map(Integer::parseInt);
}

Parser<LocalDate> ld = Parser.sequence(
    digits(2).followedBy("."), digits(2).followedBy("."), digits(4),
    (dd, mm, yyyy) -> new LocalDate(yyyy, mm, dd));