The current implementation (2289a9b) is really inefficient as the pattern is recompiled after each chained method call.

This is partly due to a flaw in the original JS API that does not follow properly the builder pattern. In Java/Scala, a proper builder class should be designed instead and return a java.util.regex.Pattern object.

Hello,

could we please have a public release for 1.7?

closed

Is there some documentation (JavaDoc) available somewhere ? I do realize that the api is probably pretty obvious and self-documentimg, but some docs would be nice.

I'm planning on porting the tests from the JS implemntation to this one and I'm thinking we should use JUnit just to stay within the same family of testing frameworks. What's everyone's opinion on that?

The expression:

regex().add("Java").zeroOrMore().build();

should generate the regex: /(?:Java)*/, just as the expression:

regex().maybe("Java").build();

generates the regex: /(?:Java)?/. However, the first expression actually generates the regex: /Java*/, which is not correct. The oneOrMore() method suffers from the similar problem.

I propose to change both zeroOrMore() and oneOrMore() to accept a string, much as the maybe() method does so it can return the correct result.

Hello,
The method lineBreak() contains a capturing group, which results in shifting of group numbers; the following test fails:

    final VerbalExpression expression = VerbalExpression.regex().
                        lineBreak()
                       .capture().find("some").endCapture().then(" text")
                       .build();
        assertEquals("some", expression.getText("\nsome text", 1));

Cheers

Currently the range function seems to only allow Integer ranges, though the javascript version seems to allow characters: https://github.com/VerbalExpressions/JSVerbalExpressions/wiki/.range()

In order to add the regex for charcters "0-9A-Za-z." I had to use add("[0-9A-Za-z.]+") but should this be possible with the range function if it worked as the javascript one does? I also understand that the class is pending a large pull request currently so it might be already fixed in that?

It seems to me that the following expression:

VerbalExpression testRegex = regex()
                .capture()
                .find("abc")
                .or("def")
                .build();

should evaluate to the regex: /(?:((?:abc)|(?:(?:def))))/, but instead it evaluates to: /(?:((?:abc))|(?:(?:def)))/. As a result, if we test this expression against the string "def" it produces a match but no group is captured. This happens because the implementation of or() closes any opening parenthesis it finds in the string that precedes it.

I don't know why or() was implemented this way, but I believe the implementation of oneOf() I propose in #31 may fix this problem.

The public Builder removeModifier(final char pModifier) method in class Builder makes use of XOR operation such as modifiers ^= Pattern.CASE_INSENSITIVE;, which may accidentally switch on the flag and cause opposite result.

This issue has not been discovered in the tests.

E.g. the testWithAnyCaseIsFalse() method in class BasicFunctionalityUnitTest calls the withAnyCase(false) after withAnyCase(), therefore the modifier is accidentally reset.

@Test
public void testWithAnyCaseIsFalse() {
    VerbalExpression testRegex = regex()
            .withAnyCase()
            .startOfLine()
            .then("a")
            .withAnyCase(false)
            .build();

    assertThat(testRegex, not(matchesTo("A")));
}

It would be more robust using bitwise AND with NOT operation. For example,

modifiers &= ~Pattern.CASE_INSENSITIVE;

Would you mind stating the license for this project, so that we know whether it is legal to inherit this in our project ?

The following tests are missing:

• range method
• word method
• multiply method

Why not just release a binary (a .jar file).
I got it all working with maven, but it's such a pain in the ass.

The (?<name>...) syntax is not supported

How can JavaVerbalExpressions build a simple regex like this: [\d,]+

VerbalExpression.regex().anyOf("0123456789,").oneOrMore().build()

It 's too ugly! How about this one: [a-k\s\d,]+ ?

It would be nice to add a anyOf method that can used like this:

VerbalExpression.regex().anyOf(DigitCharSet, WordCharSet, SpaceCharSet ,";:,\\").oneOrMore().build()

Now getText(str, 1) returns concatenation of all groups that was found. Need ability to return it as List<String>

Hi,

I would like to suggest adding support for RegEx lookarounds. Cheatsheet in this link.

Regards.

Is it can be finded in any repo?

Wouldn't it be nice to add in the API the option to get the spans of the matches, in addition to just the matches, in the spirit of these python and Java implementation?

https://stackoverflow.com/a/250303/1509695
https://docs.oracle.com/javase/7/docs/api/java/util/regex/Matcher.html#start()

Or is this already baked in and I missed it in the source or unit-tests code?

Please clarify, can I build regex like "(\d{1} Aaa)|(\d{2} Bbb)" using JavaVerbalExpressions?

As I see word boundary isn't supported(\b)?
Or how to write an expression to find just exactly word?
For example:

String text = "Test about me";
String regex = "\\babout\\b";

The POM has the build source and target set to 1.6 but the code does not exist until 1.7.

Specifically, the code:
VerbalExpression::addModifier(char):161

contains:
Pattern.UNICODE_CHARACTER_CLASS;

which doesn't exist until 1.7, but the compiler plugin is specifying 1.6.

I can do add("[0-9.,]") but it defies the purpose of the library.

I have to find all occurrences of dates in an email: each occurrence and the startIndex and endIndex of the occurrence. I would like to use a human-readable regex builder like JavaVerbalExpressions, but looking at the API I see no way to extract the match details like startIndex and endIndex, I only see test and testExact returning a boolean.

Is it possible to loop over all matches and get the start and end indexes and all match details (group names etc)? Thanks!

I think it would be better if we use constants for specifying modifiers. Inside the code, as it is constants are being used. I can send a PR maybe if you think this would be good.

Actually generated: (?:[^abb]*)
Expected to be generated: (?:a(?!bb)|[^a])+
or something like that.