caseInsensitie() returns Parser<?> to avoid copy

Author: fluentfuture

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

@@ -269,29 +269,35 @@ public static Parser<String> string(String value) {
   /**
    * Matches a literal {@code string} case insensitively.
    *
+   * <p>If you need to access the input substring that matched case insensitively,
+   * you can use {@code .source()}.
+   *
    * @since 9.9.3
    */
-  public static Parser<String> caseInsensitive(String value) {
-    checkArgument(value.length() > 0, "value cannot be empty");
-    return new Parser<>() {
+  public static Parser<?> caseInsensitive(String string) {
+    checkArgument(string.length() > 0, "value cannot be empty");
+    return new Parser<String>() {
       @Override MatchResult<String> skipAndMatch(
           Parser<?> skip, CharInput input, int start, ErrorContext context) {
         start = skipIfAny(skip, input, start);
-        if (input.startsWithCaseInsensitive(value, start)) {
+        if (input.startsWithCaseInsensitive(string, start)) {
           return new MatchResult.Success<>(
-              start, start + value.length(), input.snippet(start, value.length()));
+              start, start + string.length(), input.snippet(start, string.length()));
         }
-        return context.expecting(value, start);
+        return context.expecting(string, start);
       }
     };
   }
 
   /**
    * {@code caseInsensitiveWord("or")} matches "Or" and "OR", but not "orange", case insensitively.
    *
+   * <p>If you need to access the input substring that matched case insensitively,
+   * you can use {@code .source()}.
+   *
    * @since 9.9.3
    */
-  public static Parser<String> caseInsensitiveWord(String word) {
+  public static Parser<?> caseInsensitiveWord(String word) {
     return caseInsensitive(word).notImmediatelyFollowedBy(CharPredicate.WORD, "[a-zA-Z0-9_]");
   }
 

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

@@ -9,9 +9,9 @@
 import static com.google.common.labs.parse.Parser.digits;
 import static com.google.common.labs.parse.Parser.first;
 import static com.google.common.labs.parse.Parser.literally;
+import static com.google.common.labs.parse.Parser.one;
 import static com.google.common.labs.parse.Parser.quotedBy;
 import static com.google.common.labs.parse.Parser.sequence;
-import static com.google.common.labs.parse.Parser.one;
 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;
@@ -165,7 +165,7 @@ public void string_cannotBeEmpty() {
 
   @Test
   public void caseInsensitive_success() {
-    Parser<String> parser = caseInsensitive("foo");
+    Parser<String> parser = caseInsensitive("foo").source();
     assertThat(parser.parse("FoO")).isEqualTo("FoO");
     assertThat(parser.matches("FoO")).isTrue();
     assertThat(parser.parseToStream("fOo")).containsExactly("fOo");
@@ -174,7 +174,7 @@ public void caseInsensitive_success() {
 
   @Test
   public void caseInsensitive_success_source() {
-    Parser<String> parser = caseInsensitive("foo");
+    Parser<String> parser = caseInsensitive("foo").source();
     assertThat(parser.source().parse("FoO")).isEqualTo("FoO");
     assertThat(parser.source().matches("FoO")).isTrue();
     assertThat(parser.source().parseToStream("fOo")).containsExactly("fOo");
@@ -250,8 +250,8 @@ public void word_skipping_failIfFollowedByWordChar() {
 
   @Test
   public void caseInsensitiveWord_success() {
-    assertThat(caseInsensitiveWord("foo").parse("FoO")).isEqualTo("FoO");
-    assertThat(caseInsensitiveWord("foo").matches("FoO")).isTrue();
+    assertThat(caseInsensitiveWord("foo").source().parse("FoO")).isEqualTo("FoO");
+    assertThat(caseInsensitiveWord("foo").source().matches("FoO")).isTrue();
   }
 
   @Test
@@ -266,17 +266,17 @@ public void caseInsensitiveWord_failIfFollowedByWordChar() {
 
   @Test
   public void caseInsensitiveWord_successIfNotFollowedByWordChar() {
-    assertThat(caseInsensitiveWord("foo").probe("FoO?")).containsExactly("FoO");
-    assertThat(caseInsensitiveWord("foo").probe("FoO-")).containsExactly("FoO");
+    assertThat(caseInsensitiveWord("foo").source().probe("FoO?")).containsExactly("FoO");
+    assertThat(caseInsensitiveWord("foo").source().probe("FoO-")).containsExactly("FoO");
   }
 
   @Test
   public void caseInsensitiveWord_skipping_success() {
-    assertThat(caseInsensitiveWord("foo").skipping(Character::isWhitespace).parseToStream("fOo"))
+    assertThat(caseInsensitiveWord("foo").source().skipping(Character::isWhitespace).parseToStream("fOo"))
         .containsExactly("fOo");
-    assertThat(caseInsensitiveWord("foo").skipping(Character::isWhitespace).parseToStream("FoO fOO"))
+    assertThat(caseInsensitiveWord("foo").source().skipping(Character::isWhitespace).parseToStream("FoO fOO"))
         .containsExactly("FoO", "fOO");
-    assertThat(caseInsensitiveWord("foo").skipping(Character::isWhitespace).probe(" FoO-fOo"))
+    assertThat(caseInsensitiveWord("foo").source().skipping(Character::isWhitespace).probe(" FoO-fOo"))
         .containsExactly("FoO");
   }