rft - non backward compatibility - change multiply method same as in original JS implementation

add - oneOrMore, zeroOrMore and atLeast methods
add - one more complex example

Author: MerkushevKirill

src/main/java/ru/lanwen/verbalregex/VerbalExpression.java

@@ -3,6 +3,8 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import static java.lang.String.valueOf;
+
 public class VerbalExpression {
 
     private final Pattern pattern;
@@ -16,6 +18,7 @@ public static class Builder {
 
         /**
          * Package private. Use {@link #regex()} to build a new one
+         *
          * @since 1.2
          */
         Builder() {
@@ -70,6 +73,7 @@ public Builder add(final String pValue) {
 
         /**
          * Append a regex from builder and wrap it with unnamed group (?: ... )
+         *
          * @param regex - VerbalExpression.Builder, that not changed
          * @return this builder
          * @since 1.2
@@ -407,6 +411,15 @@ public Builder withAnyCase(final boolean pEnable) {
             return this;
         }
 
+        /**
+         * Turn ON matching with ignoring case
+         * Example:
+         * // matches "a"
+         * // matches "A"
+         * regex().find("a").withAnyCase()
+         *
+         * @return this builder
+         */
         public Builder withAnyCase() {
             return withAnyCase(true);
         }
@@ -420,16 +433,59 @@ public Builder searchOneLine(final boolean pEnable) {
             return this;
         }
 
-        public Builder multiple(final String pValue) {
-            switch (pValue.charAt(0)) {
-                case '*':
-                case '+':
-                    return this.add(pValue);
+        /**
+         * Convenient method to show that string usage count is exact count, range count or simply one or more
+         * Usage:
+         * regex().multiply("abc")                                  // Produce (?:abc)+
+         * regex().multiply("abc", null)                            // Produce (?:abc)+
+         * regex().multiply("abc", (int)from)                       // Produce (?:abc){from}
+         * regex().multiply("abc", (int)from, (int)to)              // Produce (?:abc){from, to}
+         * regex().multiply("abc", (int)from, (int)to, (int)...)    // Produce (?:abc)+
+         *
+         * @param pValue - the string to be looked for
+         * @param count  - (optional) if passed one or two numbers, it used to show count or range count
+         * @return this builder
+         * @see #oneOrMore()
+         * @see #then(String)
+         * @see #zeroOrMore()
+         */
+        public Builder multiple(final String pValue, final int... count) {
+            if (count == null) {
+                return this.then(pValue).oneOrMore();
+            }
+            switch (count.length) {
+                case 1:
+                    return this.then(pValue).count(count[0]);
+                case 2:
+                    return this.then(pValue).count(count[0], count[1]);
                 default:
-                    return this.add(this.sanitize(pValue) + '+');
+                    return this.then(pValue).oneOrMore();
             }
         }
 
+        /**
+         * Adds "+" char to regexp
+         * Same effect as {@link #atLeast(int)} with "1" argument
+         * Also, used by {@link #multiple(String, int...)} when second argument is null, or have length more than 2
+         *
+         * @return this builder
+         * @since 1.2
+         */
+        public Builder oneOrMore() {
+            return this.add("+");
+        }
+
+        /**
+         * Adds "*" char to regexp, means zero or more times repeated
+         * Same effect as {@link #atLeast(int)} with "0" argument
+         *
+         * @return this builder
+         * @since 1.2
+         */
+        public Builder zeroOrMore() {
+            return this.add("*");
+        }
+
         /**
          * Add count of previous group
          * for example:
@@ -458,6 +514,22 @@ public Builder count(final int from, final int to) {
             return this;
         }
 
+        /**
+         * Produce range count with only minimal number of occurrences
+         * for example:
+         * .find("w").atLeast(1) // produce (?:w){1,}
+         *
+         * @param from - minimal number of occurrences
+         * @return this Builder
+         * @see #count(int)
+         * @see #oneOrMore()
+         * @see #zeroOrMore()
+         * @since 1.2
+         */
+        public Builder atLeast(final int from) {
+            return this.add("{").add(valueOf(from)).add(",}");
+        }
+
         /**
          * Add a alternative expression to be matched
          *
@@ -505,12 +577,11 @@ public Builder capt() {
          * Same as {@link #capture()}, but don't save result
          * May be used to set count of duplicated captures, without creating a new saved capture
          * Example:
-         *      // Without group() - count(2) applies only to second capture
-         *      regex().group()
-         *          .capt().range("0", "1").endCapt().tab()
-         *          .capt().digit().count(5).endCapt()
-         *          .endGr().count(2);
-         *
+         * // Without group() - count(2) applies only to second capture
+         * regex().group()
+         * .capt().range("0", "1").endCapt().tab()
+         * .capt().digit().count(5).endCapt()
+         * .endGr().count(2);
          *
          * @return this builder
          * @since 1.2
@@ -537,6 +608,7 @@ public Builder endCapture() {
 
         /**
          * Shortcut for {@link #endCapture()}
+         *
          * @return this builder
          * @since 1.2
          */
@@ -545,11 +617,12 @@ public Builder endCapt() {
         }
 
         /**
-         * Closes current unnamed and unsaved group
+         * Closes current unnamed and unmatching group
          * Shortcut for {@link #endCapture()}
          * Use it with {@link #group()} for prettify code
          * Example:
-         *      regex().group().maybe("word").count(2).endGr()
+         * regex().group().maybe("word").count(2).endGr()
+         *
          * @return this builder
          * @since 1.2
          */

src/test/java/ru/lanwen/verbalregex/BasicFunctionalityUnitTest.java

@@ -5,6 +5,7 @@
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
 import static ru.lanwen.verbalregex.VerbalExpression.regex;
+import static ru.lanwen.verbalregex.matchers.EqualToRegexMatcher.equalToRegex;
 import static ru.lanwen.verbalregex.matchers.TestMatchMatcher.matchesTo;
 import static ru.lanwen.verbalregex.matchers.TestsExactMatcher.matchesExactly;
 
@@ -352,6 +353,24 @@ public void testOrWithCapture() {
         assertThat(testRegex.getText("xxxabcdefzzz", 2), equalTo("abcnull"));
     }
 
+
+    @Test
+    public void testOrWithClosedCapture() {
+        VerbalExpression testRegex = regex()
+                .capture()
+                .find("abc")
+                .endCapt()
+                .or("def")
+                .build();
+        assertThat("Starts with abc or def", testRegex, matchesTo("defzzz"));
+        assertThat("Starts with abc or def", testRegex, matchesTo("abczzz"));
+        assertThat("Doesn't start with abc or def", testRegex, not(matchesExactly("xyzabcefg")));
+
+        assertThat(testRegex.getText("xxxabcdefzzz", 1), equalTo("abcnull"));
+        assertThat(testRegex.getText("xxxdefzzz", 2), equalTo("null"));
+        assertThat(testRegex.getText("xxxabcdefzzz", 2), equalTo("abcnull"));
+    }
+
     @Test
     public void addRegexBuilderWrapsItWithUnsavedGroup() throws Exception {
         VerbalExpression regex = regex()
@@ -366,4 +385,83 @@ public void addRegexBuilderWrapsItWithUnsavedGroup() throws Exception {
         assertThat(regex, matchesExactly(example + example));
         assertThat(regex, not(matchesExactly(example2digit)));
     }
+
+    @Test
+    public void multiplyWith1NumProduceSameAsCountResult() throws Exception {
+        VerbalExpression regex = regex().multiple("a", 1).build();
+
+        assertThat(regex, equalToRegex(regex().find("a").count(1)));
+    }
+
+    @Test
+    public void multiplyWith2NumProduceSameAsCountRangeResult() throws Exception {
+        VerbalExpression regex = regex().multiple("a", 1, 2).build();
+
+        assertThat(regex, equalToRegex(regex().find("a").count(1, 2)));
+    }
+
+    @Test
+    public void atLeast1HaveSameEffectAsOneOrMore() throws Exception {
+        VerbalExpression regex = regex().find("a").atLeast(1).build();
+
+        String matched = "aaaaaa";
+        String oneMatchedExactly = "a";
+        String oneMatched = "ab";
+        String empty = "";
+
+        assertThat(regex, matchesExactly(matched));
+        assertThat(regex, matchesExactly(oneMatchedExactly));
+        assertThat(regex, not(matchesExactly(oneMatched)));
+        assertThat(regex, matchesTo(oneMatched));
+        assertThat(regex, not(matchesTo(empty)));
+    }
+
+    @Test
+    public void oneOreMoreSameAsAtLeast1() throws Exception {
+        VerbalExpression regexWithOneOrMore = regex().find("a").oneOrMore().build();
+
+        String matched = "aaaaaa";
+        String oneMatchedExactly = "a";
+        String oneMatched = "ab";
+        String empty = "";
+
+        assertThat(regexWithOneOrMore, matchesExactly(matched));
+        assertThat(regexWithOneOrMore, matchesExactly(oneMatchedExactly));
+        assertThat(regexWithOneOrMore, not(matchesExactly(oneMatched)));
+        assertThat(regexWithOneOrMore, matchesTo(oneMatched));
+        assertThat(regexWithOneOrMore, not(matchesTo(empty)));
+    }
+
+    @Test
+    public void atLeast0HaveSameEffectAsZeroOrMore() throws Exception {
+        VerbalExpression regex = regex().find("a").atLeast(0).build();
+
+        String matched = "aaaaaa";
+        String oneMatchedExactly = "a";
+        String oneMatched = "ab";
+        String empty = "";
+
+        assertThat(regex, matchesExactly(matched));
+        assertThat(regex, matchesExactly(oneMatchedExactly));
+        assertThat(regex, not(matchesExactly(oneMatched)));
+        assertThat(regex, matchesTo(empty));
+        assertThat(regex, matchesExactly(empty));
+    }
+
+    @Test
+    public void zeroOreMoreSameAsAtLeast0() throws Exception {
+        VerbalExpression regexWithOneOrMore = regex().find("a").zeroOrMore().build();
+
+        String matched = "aaaaaa";
+        String oneMatchedExactly = "a";
+        String oneMatched = "ab";
+        String empty = "";
+
+        assertThat(regexWithOneOrMore, matchesExactly(matched));
+        assertThat(regexWithOneOrMore, matchesExactly(oneMatchedExactly));
+        assertThat(regexWithOneOrMore, not(matchesExactly(oneMatched)));
+        assertThat(regexWithOneOrMore, matchesTo(oneMatched));
+        assertThat(regexWithOneOrMore, matchesTo(empty));
+        assertThat(regexWithOneOrMore, matchesExactly(empty));
+    }
 }

src/test/java/ru/lanwen/verbalregex/NegativeCasesTest.java

@@ -7,6 +7,7 @@
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
+import static ru.lanwen.verbalregex.VerbalExpression.regex;
 import static ru.lanwen.verbalregex.matchers.TestMatchMatcher.matchesTo;
 
 /**
@@ -18,37 +19,37 @@ public class NegativeCasesTest {
 
     @Test(expected = IllegalStateException.class)
     public void testEndCaptureOnEmptyRegex() {
-        VerbalExpression.regex().endCapture().build();
+        regex().endCapture().build();
     }
 
     @Test(expected = IndexOutOfBoundsException.class)
     public void shouldExceptionWhenTryGetMoreThanCapturedGroup() {
         String text = "abc";
-        VerbalExpression regex = VerbalExpression.regex().find("b").capture().find("c").build();
+        VerbalExpression regex = regex().find("b").capture().find("c").build();
 
         regex.getText(text, 2);
     }
 
     @Test(expected = PatternSyntaxException.class)
     public void testRangeWithoutArgs() throws Exception {
-        VerbalExpression.regex().startOfLine().range().build();
+        regex().startOfLine().range().build();
     }
 
     @Test(expected = PatternSyntaxException.class)
     public void testRangeWithOneArg() throws Exception {
-        VerbalExpression.regex().startOfLine().range("a").build();
+        regex().startOfLine().range("a").build();
     }
 
     @Test
     public void rangeWithThreeArgsUsesOnlyFirstTwo() throws Exception {
-        VerbalExpression regex = VerbalExpression.regex().startOfLine().range("a", "z", "A").build();
+        VerbalExpression regex = regex().startOfLine().range("a", "z", "A").build();
 
         assertThat("Range with three args differs from expected", regex.toString(), equalTo("^[a-z]"));
     }
 
     @Test
     public void orWithNullMatchesAny() throws Exception {
-        VerbalExpression regex = VerbalExpression.regex().startOfLine().then("a").or(null).build();
+        VerbalExpression regex = regex().startOfLine().then("a").or(null).build();
         assertThat("regex don't matches writed letter", regex, matchesTo("a"));
         assertThat("or(null) should match any", regex, matchesTo("bcd"));
 
@@ -57,7 +58,7 @@ public void orWithNullMatchesAny() throws Exception {
 
     @Test
     public void orAfterCaptureProduceEmptyGroup() throws Exception {
-        VerbalExpression regex = VerbalExpression.regex().startOfLine().then("a").capture().or("b").build();
+        VerbalExpression regex = regex().startOfLine().then("a").capture().or("b").build();
 
         assertThat(regex.toString(), containsString("()|"));
 
@@ -66,4 +67,26 @@ public void orAfterCaptureProduceEmptyGroup() throws Exception {
         assertThat("second group should produce empty string", regex.getText("abcd", 2), equalTo(""));
 
     }
+
+    @Test
+    public void multiplyWithNullOnCountEqualToWithOneAndMore() throws Exception {
+        VerbalExpression regex = regex().multiple("some", null).build();
+
+        assertThat("Multiply with null should be equal to oneOrMore",
+                regex.toString(), equalTo(regex().find("some").oneOrMore().build().toString()));
+    }
+
+    @Test
+    public void multiplyWithMoreThan3ParamsOnCountEqualToWithOneAndMore() throws Exception {
+        VerbalExpression regex = regex().multiple("some", 1, 2, 3).build();
+
+        assertThat("Multiply with 3 args should be equal to oneOrMore",
+                regex.toString(), equalTo(regex().find("some").oneOrMore().build().toString()));
+    }
+
+    @Test(expected = java.util.regex.PatternSyntaxException.class)
+    public void twoOpenCaptsWithOrThrowSyntaxException() throws Exception {
+        VerbalExpression regex = regex().capt().capt().or("0").build();
+        String ignored = regex.toString();
+    }
 }