tony19 / named-regexp Goto Github PK

Hi!

I've just found a possible bug in the library, the following snippet will works with 0.2.6 and throw an exception with 0.2.7:

        final String regex = "/teamDrawer/(?<roomId>.*)";
        final String url = "/teamDrawer/12345";

        final Matcher matcher = Pattern.compile(regex).matcher(url);
        final Integer count = matcher.namedGroups().size();
        final Integer mapCount = matcher.namedGroups().get(0).size();
        final String value = matcher.namedGroups().get(0).get("roomId");

The root cause is the .namedGroups() can only callable once in the version 0.2.7, with the other calls it will return an empty list, maybe the !matcher.hitEnd() prevent it to fill up the list of maps again.

--

I'm using it with Kotlin, so, it turned out that it was called several times in under the hood:

        Pattern.compile(pattern).matcher(url).let {
            when {
                it.matches() && it.groupCount() > 0 -> Router.Parameters.Match(it.namedGroups().firstOrNull() ?: mapOf())
                ... -> ...
            }
        }

given:

    Pattern pattern = Pattern.compile("(?<digit>\\d)(\\w)");
    Matcher matcher = pattern.matcher("2foo3bar4");

when

    matcher.namedGroups();

then
Only the first group is being found due to reseting of matcher.

There is no release available that include your latest commits, f.e. the namedGroup fix for when goupNames() is empty.

java.lang.RuntimeException: An error occured while executing doInBackground()
at android.os.AsyncTask$3.done(AsyncTask.java:304)
at java.util.concurrent.FutureTask.finishCompletion(FutureTask.java:355)
at java.util.concurrent.FutureTask.setException(FutureTask.java:222)
at java.util.concurrent.FutureTask.run(FutureTask.java:242)
at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:231)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1112)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:587)
at java.lang.Thread.run(Thread.java:818)
Caused by: java.lang.NoClassDefFoundError: Failed resolution of: Lcom/google/code/regexp/Pattern;
at com.android.beewisesdk.PopulateMessagesAsyncTask.populate_messages(BW.java:880)
at com.android.beewisesdk.PopulateMessagesAsyncTask.doInBackground(BW.java:320)
at com.android.beewisesdk.PopulateMessagesAsyncTask.doInBackground(BW.java:251)
at android.os.AsyncTask$2.call(AsyncTask.java:292)
at java.util.concurrent.FutureTask.run(FutureTask.java:237)
at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:231) 
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1112) 
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:587) 
at java.lang.Thread.run(Thread.java:818) 
Caused by: java.lang.ClassNotFoundException: Didn't find class "com.google.code.regexp.Pattern" on path: DexPathList[[zip file "/data/app/com.citrus.citruspay-1/base.apk"],nativeLibraryDirectories=[/data/app/com.citrus.citruspay-1/lib/arm, /vendor/lib, /system/lib]]
at dalvik.system.BaseDexClassLoader.findClass(BaseDexClassLoader.java:56)
at java.lang.ClassLoader.loadClass(ClassLoader.java:511)
at java.lang.ClassLoader.loadClass(ClassLoader.java:469)

Matcher.namedGroups() is faulty, because when I have no groups in my pattern, the while loop never quits, and causes out of memory exception.

Details: nextIndex is only updated in the for, but when parentPattern.groupNames() is empty, it never enters it.

My use case is to use your lib with dynamic regexes (I'm writing a regex capable router, that can extract parameters from URLs, so they may or may not contain groups), so I cannot determine without your lib if they have groups or not, so I cannot use the built-in regex, if I don't have groups.

Edit: I just discovered groupCount(), but still it would be nice if it wouldn't be needed.

Describe the bug

The project fails to compile at the Java 21 language level.

Reproduction

JAVA_HOME=<path to JDK 21> mvn install

Logs

[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.12.1:compile (default-compile) on project named-regexp: Compilation failure: Compilation failure:
[ERROR] ./named-regexp/src/main/java/com/google/code/regexp/Matcher.java:[314,38] namedGroups() in com.google.code.regexp.Matcher cannot implement namedGroups() in java.util.regex.MatchResult
[ERROR]   return type java.util.List<java.util.Map<java.lang.String,java.lang.String>> is not compatible with java.util.Map<java.lang.String,java.lang.Integer>
[ERROR] .,/named-regexp/src/main/java/com/google/code/regexp/MatchResult.java:[44,38] namedGroups() in com.google.code.regexp.MatchResult clashes with namedGroups() in java.util.regex.MatchResult
[ERROR]   return type java.util.List<java.util.Map<java.lang.String,java.lang.String>> is not compatible with java.util.Map<java.lang.String,java.lang.Integer>

Validations

• Follow our Code of Conduct
• Read the Contributing Guide.
• Check that there isn't already an issue that reports the same bug to avoid creating a duplicate.
• Check that this is a concrete bug. For Q&A, please open a GitHub Discussion instead.
• The provided reproduction is a minimal reproducible of the bug.

I was going to log this bug on your Jira, but the Jira captcha is broken for new signups (https://jira.atlassian.com/browse/JRA-34421).

Parenthesis in a character class don't need to be escaped in a regex string. The Pattern#countOpenParens function does not account for this, and will count parenthesis in a character class as a group. This leads to the index being off for all named groups following the character class.

Here is a unit test that will fail due to this:

@Test
public void testIndexOfNamedGroupAfterNonEscapedParenInCharacterClass() {
    Pattern p = Pattern.compile("(a)(?<foo>[()])(?:c)(?<named>x)");
    assertEquals(2, p.indexOf("named"));
}

Hi,

I noticed that wrapper Pattern class doesn't expose the constants defined in java.util.regex.Pattern
class.

So we end up writing code like below:

Pattern pattern = Pattern.compile(patternString, java.util.regex.Pattern.CASE_INSENSITIVE);

Can we expose those constants through Pattern class itself, like

Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);

In above Pattern is com.google.code.regex.Pattern

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

This repository currently has no open or pending branches.

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

I don't know whether this is still maintained, but there's a bug when using the Matcher.appendReplacement that removes escaping of characters like "\s". Here's a code example:

Pattern pattern = Pattern.compile("[0-9]");
Matcher matcher = pattern.matcher("12345");
StringBuffer buffer = new StringBuffer();
while (matcher.find()) {
    matcher.appendReplacement(buffer, matcher.group() + "\\s");
}
matcher.appendTail(buffer);
System.out.println(buffer);

This should print "1\s2\s3\s4\s5\s" but prints "1s2s3s4s5s".

When checking parenthesis in a character class, need to exclude quoted '[' and ']' characters. This could lead to the index being off for all named groups following the quoted characters.

Here is a unit test that will fail due to this:

@test
public void testIndexOfNamedGroupAfterNonEscapedParenInQuote() {
Pattern p = Pattern.compile("\Q[\E(?<foo>x)(?<bar>y)");
assertEquals(1, p.indexOf("bar"));
}

The following code snippet leads to an endless loop in matcher.namedGroups() and eventually to an OutOfMemoryError:

com.google.code.regexp.Matcher matcher = com.google.code.regexp.Pattern.compile("(?<foo>.*)").matcher("bar");
System.out.println(matcher.namedGroups());

Tested with v0.2.6

I would expect that

1. the expression (?<foo>.*) matched the whole String bar once, because .* is greedy (as opposed to .*?)
2. no endless loop / OOME occurs, for any given pattern

It seems that if the pattern matches an empty string, an infinite loop occurs when using Matcher.namedGroups, even if the matched input isn't an empty string. Here's a code example:

Pattern pattern = Pattern.compile("(?<first>A)?(?<second>B)?");
Matcher matcher = pattern.matcher("AB");
if(matcher.matches()) {
    matcher.namedGroups();
}