zeroOrMore(characterSet)

Author: fluentfuture

dot-parse/README.md

@@ -79,8 +79,9 @@ you can nest it between parentheses.
 
 ## Example — Parse Regex-like Character Set
 
-The `Parser.anyCharIn()` and `Parser.oneOrMoreCharsIn()` accept a character set string.
-And you can call it with `anyCharIn("[0-9a-fA-F]")`, `oneOrMoreCharsIn("[^0-9]")` etc.
+The `Parser.anyCharIn()`, `Parser.oneOrMoreCharsIn()` and `Parser.zeroOrMoreCharsIn()` methods
+accept a character set string. And you can call it with `anyCharIn("[0-9a-fA-F]")`,
+`oneOrMoreCharsIn("[^0-9]")` etc.
 
 It makes it easier to create a primitive parser using a regex-like character set specification
 if you are already familiar with them.
@@ -124,7 +125,7 @@ Parser<CharPredicate> singleChar = supportedChar.map(CharPredicate::is);
 ```
 Regex character set doesn't allow literal `']'`. 
 
-And the API decides not to support escaping because escaping rule is pretty complex
+The API decides not to support escaping because escaping rule is pretty complex
 and they hurt readability (particularly in Java where you can easily get lost on the
 number of backslashes you need). Instead, for use cases that need these special characters,
 there's always the `single(CharPredicate)` and `consecutive(CharPredicate)` to programmatically

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

@@ -463,6 +463,22 @@ public final <A, R> Parser<R> atLeastOnceDelimitedBy(
         });
   }
 
+  /**
+   * Starts a fluent chain for matching zero or more characters in the given {@code characterSet}. If no
+   * such character is found, empty string is the result.
+   *
+   * <p>For example if you need to parse a quoted literal that's allowed to be empty:
+   *
+   * <pre>{@code
+   * zeroOrMoreCharsIn("[^']").between("'", "'")
+   * }</pre>
+   *
+   * @since 9.4
+   */
+  public static Parser<String>.OrEmpty zeroOrMoreCharsIn(String characterSet) {
+    return oneOrMoreCharsIn(characterSet).orElse("");
+  }
+
   /**
    * Starts a fluent chain for matching consecutive {@code charsToMatch} zero or more times. If no
    * such character is found, empty string is the result.
@@ -1526,8 +1542,8 @@ private static CharPredicate compileCharacterSet(String characterSet) {
         "Character set must be in square brackets. Use [%s] instead.", characterSet);
     checkArgument(
         !characterSet.contains("\\"),
-        "Escaping (%s) not supported. "
-        + "Please use single(CharePredicate) or consecutive(CharPredicate) instead.",
+        "Escaping (%s) not supported in a character set. "
+            + "Please use single(CharePredicate) or consecutive(CharPredicate) instead.",
         characterSet);
     Parser<Character> validChar = single(isNot(']'), "character");
     Parser<CharPredicate> range =

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

@@ -9,6 +9,7 @@
 import static com.google.common.labs.parse.Parser.string;
 import static com.google.common.labs.parse.Parser.word;
 import static com.google.common.labs.parse.Parser.zeroOrMore;
+import static com.google.common.labs.parse.Parser.zeroOrMoreCharsIn;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth8.assertThat;
 import static com.google.mu.util.CharPredicate.is;
@@ -3193,6 +3194,62 @@ public void zeroOrMore_charMatcher_matchesMultipleTimes_source() {
         .containsExactly("[ 123 ]");
   }
 
+  @Test
+  public void zeroOrMore_charSet_matchesZeroTimes() {
+    Parser<String> parser = zeroOrMoreCharsIn("[0-9]").between("[", "]");
+    assertThat(parser.parse("[]")).isEmpty();
+    assertThat(parser.parseToStream("[]")).containsExactly("");
+    assertThat(parser.parseSkipping(Character::isWhitespace, "[ ]")).isEmpty();
+    assertThat(parser.skipping(Character::isWhitespace).parseToStream("[ ]")).containsExactly("");
+  }
+
+  @Test
+  public void zeroOrMore_charSet_matchesZeroTimes_source() {
+    Parser<String> parser = zeroOrMoreCharsIn("[0-9]").between("[", "]");
+    assertThat(parser.source().parse("[]")).isEqualTo("[]");
+    assertThat(parser.source().parseToStream("[]")).containsExactly("[]");
+    assertThat(parser.source().parseSkipping(Character::isWhitespace, "[ ]")).isEqualTo("[ ]");
+    assertThat(parser.source().skipping(Character::isWhitespace).parseToStream("[ ]")).containsExactly("[ ]");
+  }
+
+  @Test
+  public void zeroOrMore_charSet_matchesOneTime() {
+    Parser<String> parser = zeroOrMoreCharsIn("[0-9]").between("[", "]");
+    assertThat(parser.parse("[1]")).isEqualTo("1");
+    assertThat(parser.parseToStream("[1]")).containsExactly("1");
+    assertThat(parser.parseSkipping(Character::isWhitespace, "[ 1 ]")).isEqualTo("1");
+    assertThat(parser.skipping(Character::isWhitespace).parseToStream("[ 1 ]")).containsExactly("1");
+  }
+
+  @Test
+  public void zeroOrMore_charSet_matchesOneTime_source() {
+    Parser<String> parser = zeroOrMoreCharsIn("[0-9]").between("[", "]");
+    assertThat(parser.source().parse("[1]")).isEqualTo("[1]");
+    assertThat(parser.source().parseToStream("[1]")).containsExactly("[1]");
+    assertThat(parser.source().parseSkipping(Character::isWhitespace, "[ 1 ]")).isEqualTo("[ 1 ]");
+    assertThat(parser.source().skipping(Character::isWhitespace).parseToStream("[ 1 ]"))
+        .containsExactly("[ 1 ]");
+  }
+
+  @Test
+  public void zeroOrMore_charSet_matchesMultipleTimes() {
+    Parser<String> parser = zeroOrMoreCharsIn("[0-9]").between("[", "]");
+    assertThat(parser.parse("[123]")).isEqualTo("123");
+    assertThat(parser.parseToStream("[123]")).containsExactly("123");
+    assertThat(parser.parseSkipping(Character::isWhitespace, "[ 123 ]")).isEqualTo("123");
+    assertThat(parser.skipping(Character::isWhitespace).parseToStream("[ 123 ]")).containsExactly("123");
+  }
+
+  @Test
+  public void zeroOrMore_charSet_matchesMultipleTimes_source() {
+    Parser<String> parser = zeroOrMoreCharsIn("[0-9]").between("[", "]");
+    assertThat(parser.source().parse("[123]")).isEqualTo("[123]");
+    assertThat(parser.source().parseToStream("[123]")).containsExactly("[123]");
+    assertThat(parser.source().parseSkipping(Character::isWhitespace, "[ 123 ]")).isEqualTo("[ 123 ]");
+    assertThat(parser.source().skipping(Character::isWhitespace).parseToStream("[ 123 ]"))
+        .containsExactly("[ 123 ]");
+  }
+
   @Test
   public void skipping_propagatesThroughOptional() {
     Parser<String> foo = string("foo");