how to replace capture group while preserving surrounding context?

[tqwewe]

Describe your feature request

I am unable to replace an nth's capture group when using Regex::replace/Regex::replace_all.

For example, I have the following regex: class(?:Name)?=["'](.*)["'] which matches class="container" and className='container'.

I need to replace only the container while preserving the surrounding text in the capture.

ex.replace_all(&content, |caps: &Captures| {
  let classes = caps.get(1).unwrap().as_str().to_owned() + " new-class";
  
  // What do I return here to keep the `class="` and `"` while replacing the content between?
})

[BurntSushi]

Here's one way:

fn replace(text: &str) -> String {
    lazy_static! {
        static ref RE: Regex = Regex::new(r#"(?x)
            class(?P<suffix>(?:Name)?)
            =
            (?P<open>["'])(?P<existing>.*)(?P<close>["'])
        "#).unwrap();
    }
    RE.replace_all(text, |caps: &regex::Captures| {
        format!(
            "class{suffix}={open}{existing} new-class{close}",
            suffix=&caps["suffix"],
            open=&caps["open"],
            existing=&caps["existing"],
            close=&caps["close"],
        )
    }).into_owned()
}

Playground link: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=9c070cb16dda0bb30a1871980fb8cf0c

Basically, the high level idea is to put the things that vary into capturing groups. But you could also take the approach of just splitting the entire regex into two pieces: the "before" piece and the "after" piece. It ends up being a little simpler in this case:

fn replace(text: &str) -> String {
    lazy_static! {
        static ref RE: Regex = Regex::new(r#"(?x)
            (?P<before>class(?:Name)?=["'].*)(?P<after>["'])
        "#).unwrap();
    }
    RE.replace_all(text, |caps: &regex::Captures| {
        format!(
            "{before} new-class{after}",
            before=&caps["before"],
            after=&caps["after"],
        )
    }).into_owned()
}

Playground link: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=1d2bb333370f5072e96fd9ae1ecf5b54

Note that one trick I used here was to use the infallible capturing index APIs. That is, caps["name"] instead of caps.name(..). (I also named my capture groups instead of relying on indices.) The infallible APIs can be used whenever a capturing group is guaranteed to participate in the match. Since if you have a Captures, you know a match occurred, you can infer that any capturing groups that must have been part of that match are present (although they may match the empty string). For example, I used (?P<suffix>(?:Name)?) instead of (?P<suffix>Name)? since the former guarantees that caps["suffix"] will never panic. But in the latter case, the capturing group won't be part of the match, and thus, you'd have to do something like caps.name("suffix").map_or("", |m| m.as_str()) in the replacement code.

[tqwewe]

Hi thanks for your reply! I did think of adding before and after capture groups, but I am writing a cli which take a config where the user can specify a list of regex patterns.
So for end user experience in my case, it's not great because they'll have to learn that each expression must have a before and after group - and it would be much easier for them to just have the one unnamed capture group.

I hope this feature (replacing only a captured group) may still be considered, but thank you for your reply :)

[BurntSushi]

In that case, I'd suggest just writing your own replacement routine and splice in the text you want.