OrEmpty.optionallyFollowedBy()

Author: fluentfuture

dot-parse/src/main/java/com/google/common/labs/parse/Grammar.java

@@ -1,5 +1,8 @@
 package com.google.common.labs.parse;
 
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
 import com.google.common.labs.parse.Parser.ParseException;
 import com.google.mu.util.CharPredicate;
 
@@ -46,9 +49,15 @@ default Parser<T> between(String prefix, String suffix) {
 
   /** The current grammar must be enclosed between non-empty {@code prefix} and {@code suffix}. */
   default Parser<T> between(Parser<?> prefix, Parser<?> suffix) {
-    return prefix.then(this).followedBy(suffix);
+    return Parser.sequence(prefix, this, (p, t) -> t).followedBy(suffix);
   }
 
+  /**
+   * Returns a parser that matches {@code this} pattern enclosed between {@code prefix} and {@code suffix},
+   * both allowed to be empty
+   */
+  Grammar<T> between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix);
+
   /**
    * The current grammar must be <em>immediately</em> enclosed between
    * non-empty {@code prefix} and {@code suffix} (no skippable characters as specified by {@link
@@ -67,6 +76,9 @@ default <S> Parser<S> then(Parser<S> suffix) {
     return Parser.sequence(Parser.maybeZeroWidth(this), suffix, (a, b) -> b);
   }
 
+  /** After matching the current optional (or zero-or-more) parser, proceed to match {@code suffix}.  */
+  <S> Grammar<S> then(Parser<S>.OrEmpty suffix);
+
   /** The current grammar must be followed by non-empty {@code suffix}. */
   default Parser<T> followedBy(String suffix) {
     return followedBy(Parser.string(suffix));
@@ -76,4 +88,31 @@ default Parser<T> followedBy(String suffix) {
   default Parser<T> followedBy(Parser<?> suffix) {
     return Parser.sequence(Parser.maybeZeroWidth(this), suffix, (a, b) -> a);
   }
+
+  /** The current optional (or zero-or-more) parser may optionally be followed by {@code suffix}.  */
+  <S> Grammar<T> followedBy(Parser<S>.OrEmpty suffix);
+
+  /** Returns an equivalent grammar except it allows {@code suffix} if present. */
+  Grammar<T> optionallyFollowedBy(String suffix);
+
+  /**
+   * If this parser matches, optionally applies the {@code op} function if the pattern is followed
+   * by {@code suffix}.
+   */
+  Grammar<T> optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op);
+
+  /**
+   * If this parser matches, optionally matches {@code suffix} with the {@code op} BiFunction
+   * to transform the current parser's result.
+   *
+   * <p>For example:
+   *
+   * <pre>{@code
+   * Parser<MarkdownLink> link = ...;
+   * Parser<String> title = ...;
+   * Parser<MarkdownLink> parser = link.optionallyFollowedBy(title, MarkdownLink::withTitle);
+   * }</pre>
+   */
+  <S> Grammar<T> optionallyFollowedBy(
+      Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op);
 }

dot-parse/src/main/java/com/google/common/labs/parse/Parser.java

@@ -955,7 +955,7 @@ public final Parser<T> withPostfixes(String operator, UnaryOperator<T> postfixFu
    *
    * @since 9.5
    */
-  public final Parser<T> between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix) {
+  @Override public final Parser<T> between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix) {
     return prefix.then(this).followedBy(suffix);
   }
 
@@ -1006,7 +1006,7 @@ public final <R> Parser<R> thenReturn(R result) {
    *
    * @since 10.0
    */
-  public final <R> Parser<R> then(Grammar<R> next) {
+  @Override public final <R> Parser<R> then(Parser<R>.OrEmpty next) {
     return sequence(this, next, (unused, value) -> value);
   }
 
@@ -1038,7 +1038,7 @@ public final Parser<T> suchThat(Predicate<? super T> condition, String name) {
   }
 
   /** If this parser matches, continue to match the optional {@code suffix}. */
-  public final Parser<T> followedBy(Grammar<?> suffix) {
+  public final <S> Parser<T> followedBy(Parser<S>.OrEmpty suffix) {
     return sequence(this, suffix, (value, unused) -> value);
   }
 
@@ -1057,15 +1057,15 @@ final Parser<T> followedByEof() {
   }
 
   /** Returns an equivalent parser except it allows {@code suffix} if present. */
-  public final Parser<T> optionallyFollowedBy(String suffix) {
+  @Override public final Parser<T> optionallyFollowedBy(String suffix) {
     return followedBy(string(suffix).orElse(null));
   }
 
   /**
    * If this parser matches, optionally applies the {@code op} function if the pattern is followed
    * by {@code suffix}.
    */
-  public final Parser<T> optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op) {
+  @Override public final Parser<T> optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op) {
     return optionalPostfix(string(suffix).thenReturn(op::apply));
   }
 
@@ -1083,7 +1083,7 @@ public final Parser<T> optionallyFollowedBy(String suffix, Function<? super T, ?
    *
    * @since 9.5
    */
-  public final <S> Parser<T> optionallyFollowedBy(
+  @Override public final <S> Parser<T> optionallyFollowedBy(
       Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op) {
     requireNonNull(op);
     return optionalPostfix(suffix.map(s -> p -> op.apply(p, s)));
@@ -1465,7 +1465,7 @@ private OrEmpty(Supplier<? extends T> defaultSupplier) {
      *
      * @since 9.5
      */
-    public final Parser<T>.OrEmpty between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix) {
+    @Override public final Parser<T>.OrEmpty between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix) {
       return prefix.then(this).followedBy(suffix);
     }
 
@@ -1503,12 +1503,12 @@ public Parser<List<T>>.OrEmpty delimitedBy(String delimiter) {
     }
 
     /** After matching the current optional (or zero-or-more) parser, proceed to match {@code suffix}.  */
-    public <S> Parser<S>.OrEmpty then(Parser<S>.OrEmpty suffix) {
+    @Override public <S> Parser<S>.OrEmpty then(Parser<S>.OrEmpty suffix) {
       return sequence(this, suffix, (a, b) -> b);
     }
 
     /** The current optional (or zero-or-more) parser may optionally be followed by {@code suffix}.  */
-    public <S> Parser<T>.OrEmpty followedBy(Parser<S>.OrEmpty suffix) {
+    @Override public <S> Parser<T>.OrEmpty followedBy(Parser<S>.OrEmpty suffix) {
       return sequence(this, suffix, (a, b) -> a);
     }
 
@@ -1517,10 +1517,36 @@ public <S> Parser<T>.OrEmpty followedBy(Parser<S>.OrEmpty suffix) {
      *
      * @since 9.5
      */
-    public Parser<T>.OrEmpty optionallyFollowedBy(String suffix) {
+    @Override public Parser<T>.OrEmpty optionallyFollowedBy(String suffix) {
       return followedBy(string(suffix).orElse(null));
     }
 
+    /**
+     * If this parser matches, optionally applies the {@code op} function if the pattern is followed
+     * by {@code suffix}.
+     *
+     * @since 10.0
+     */
+    @Override public final Parser<T>.OrEmpty optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op) {
+      return optionallyFollowedBy(string(suffix).thenReturn(op::apply));
+    }
+
+    /**
+     * If this parser matches, optionally matches {@code suffix} with the {@code op} BiFunction
+     * to transform the current parser's result.
+     *
+     * @since 10.0
+     */
+    @Override public final <S> Parser<T>.OrEmpty optionallyFollowedBy(
+        Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op) {
+      requireNonNull(op);
+      return optionallyFollowedBy(suffix.map(s -> p -> op.apply(p, s)));
+    }
+
+    private Parser<T>.OrEmpty optionallyFollowedBy(Parser<UnaryOperator<T>> suffix) {
+      return sequence(this, suffix.orElse(identity()), (operand, op) -> op.apply(operand));
+    }
+
     /**
      * Returns the otherwise equivalent {@code Parser} that will fail instead of returning the
      * default value if empty.
@@ -1678,7 +1704,7 @@ Stream<T> parseToStream(CharInput input, int fromIndex) {
      * input is exhausted or matching failed.
      *
      * <p>Note that unlike {@link #parseToStream(String) parseToStream()}, a matching failure
-     * terminates the stream without throwing exception.
+     * terminates the stream out throwing exception.
      *
      * <p>This allows quick probing without fully parsing it.
      */

dot-parse/src/test/java/com/google/common/labs/parse/ParserTest.java

@@ -3829,6 +3829,28 @@ public void orEmpty_optionallyFollowedBy_suffix_source() {
     assertThat(parser.source().parse("[]")).isEqualTo("[]");
   }
 
+  @Test
+  public void orEmpty_optionallyFollowedBy_string_function_success() {
+    Parser<String> parser = zeroOrMore(is('a'), "a's")
+        .optionallyFollowedBy("++", s -> s + "b")
+        .between("[", "]");
+    assertThat(parser.parse("[aa++]")).isEqualTo("aab");
+    assertThat(parser.parse("[aa]")).isEqualTo("aa");
+    assertThat(parser.parse("[]")).isEqualTo("");
+  }
+
+  @Test
+  public void orEmpty_optionallyFollowedBy_parser_biFunction_success() {
+    Parser<String> parser = zeroOrMore(is('a'), "a's")
+        .optionallyFollowedBy(
+            string("+").then(digits()).map(String::length),
+            (s, len) -> s + len)
+        .between("[", "]");
+    assertThat(parser.parse("[aa+123]")).isEqualTo("aa3");
+    assertThat(parser.parse("[aa]")).isEqualTo("aa");
+    assertThat(parser.parse("[]")).isEqualTo("");
+  }
+
   @Test
   public void parser_immediatelyBetween_success() {
     Parser<String> parser = consecutive(noneOf("[]"), "content").immediatelyBetween("[", "]");