fix: Convert Go regex to Rust regex

[fbs]

Go and Rust have some differences in their regex implementation. In Go the following is valid:

uri=~"/v[1-9]/.*/{gid}/{uid}"

Rust sees the {gid} as a bad repetition, it expects a range like {1,4}

regex parse error:
    /v[1-9]/.*/{gid}/{uid}
                ^
error: repetition quantifier expects a valid decimal

For it to be a valid Rust regex the opening { has to be escaped.

This change adds that escaping.

The implementation is simple, iteration + writing in a result buffer. It is probably not the best of nicest way of doing it, but it straight forward.

Fixes #75

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Comparison is base (6cf0736) 98.88% compared to head (8ec4d87) 98.90%.

Changes have been made to critical files, which contain lines commonly executed in production. Learn more

Additional details and impacted files

@@            Coverage Diff             @@
##             main      #76      +/-   ##
==========================================
+ Coverage   98.88%   98.90%   +0.01%     
==========================================
  Files          14       14              
  Lines        6126     6215      +89     
==========================================
+ Hits         6058     6147      +89     
  Misses         68       68              

Files	Coverage Δ
src/label/matcher.rs	100.00% <100.00%> (ø)
src/parser/parse.rs Critical	100.00% <100.00%> (ø)

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[yuanbohan]

Hi, thanks for your contribution 👍
Could you fix the clippy error? You can refer #77, or you can rebase the main branch after the PR #77 is merged

[yuanbohan]

@waynexia @evenyag please take a look

[v0y4g3r]

Looks like we only need to convert the { characters without preceding backslash (\) to \{ while remove the preceding \ from \{ in Golang regex to make it work in Rust regex.

The problem is the difference between Go and Rust in handling repetition sequence and bracket literal. Go treats { as
bracket literal while Rust treats { as the start of repetition sequence.

For example, for /v[1-9]/.*/{gid}/{uid} in Golang, the corresponding Rust regex would be /v[1-9]/.*/\{gid\}/\{uid\}: https://regex101.com/r/k7b6N8/1

[fbs]

Yes thats basically what this MR does, Go 'auto escapes' the sequence while Rust doesn't. So the conversion is a{aa} -> a\{aa} but a{1,2} stays a{1,2}

[waynexia]

Yes thats basically what this MR does, Go 'auto escapes' the sequence while Rust doesn't. So the conversion is a{aa} -> a\{aa} but a{1,2} stays a{1,2}

Should a{aa} goes to a\{aa\}? } needs escaping as well.

[yuanbohan]

Yes thats basically what this MR does, Go 'auto escapes' the sequence while Rust doesn't. So the conversion is a{aa} -> a\{aa} but a{1,2} stays a{1,2}

Should a{aa} goes to a\{aa\}? } needs escaping as well.

I'm interested in the escaping of }, maybe it does not affect the result if the regex does not find the starting of repetition pattern?

[fbs]

I'm not entirely sure what you mean. In my testing just escaping the { is enough. A } without leading (or with escaped) { is just seen as a literal

$ cat src/main.rs
use regex::Regex;

fn main() {
    let re = Regex::new(r"a}a\{a}").unwrap();
    let Some(caps) = re.captures("a}a{a}") else {
        println!("no match!");
        return;
    };
    println!("The name is: {:?}", caps);
}

/tmp/regex master[?] $ cargo r
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/regexxx`
The name is: Captures({0: 0..6/"a}a{a}"})

[waynexia]

Thanks for your contribution @fbs ❤️

[fbs]

Thanks for the quick review team! <3.

I wonder if there are more regex incompatibility issues in this.

[yuanbohan]

Thanks for the quick review team! <3.

I wonder if there are more regex incompatibility issues in this.

I will watch on this, thanks for your contribution 😀