Match balanced groups

Match balanced groups and what they hold

Match a bracket group whole however deeply it nests, keep the groups that hold something, and bind a name only inside its own group (pattern syntax).

$ cat calls.py
log(fetch(url, retries=3), level="info")
save(record)
retry(fetch(url, retries=5), backoff=2.5)
$ cat keys.json
[{"id": 1, "name": "ann", "id": 7}, {"id": 2, "name": "bob"}, {"name": "cy", "id": 3}]

A call, whatever its arguments nest

\B(...) is a balanced paren group whose interior matches the pattern inside it, and @call an identifier followed by one. A call nested in an argument stays inside the outer match:

$ trex scan '@call' calls.py
[0..40] "log(fetch(url, retries=3), level=\"info\")"
[41..53] "save(record)"
[54..95] "retry(fetch(url, retries=5), backoff=2.5)"

$ trex scan '"fetch" \B(.*)' calls.py
[4..25] "fetch(url, retries=3)"
[60..81] "fetch(url, retries=5)"

let code = "log(fetch(url, retries=3), level=\"info\")\nsave(record)\nretry(fetch(url, retries=5), backoff=2.5)\n";
let found = |src: &str| -> Vec<&str> {
    let pat = trex::parse(src).expect("valid pattern");
    trex::scan(&pat, code.as_bytes()).iter().map(|s| &code[s.range()]).collect()
};
assert_eq!(found("@call"), ["log(fetch(url, retries=3), level=\"info\")", "save(record)", "retry(fetch(url, retries=5), backoff=2.5)"]);
assert_eq!(found(r#""fetch" \B(.*)"#), ["fetch(url, retries=3)", "fetch(url, retries=5)"]);

>>> import trex
>>> code = trex.read("calls.py")
>>> [m.text for m in trex.Pattern("@call").scan(code)]
['log(fetch(url, retries=3), level="info")', 'save(record)', 'retry(fetch(url, retries=5), backoff=2.5)']
>>> [m.text for m in trex.Pattern(r'"fetch" \B(.*)').scan(code)]
['fetch(url, retries=3)', 'fetch(url, retries=5)']

PS> Select-TrexMatch '@call' -Path ./calls.py -Raw
log(fetch(url, retries=3), level="info")
save(record)
retry(fetch(url, retries=5), backoff=2.5)

PS> Select-TrexMatch '"fetch" \B(.*)' -Path ./calls.py -Raw
fetch(url, retries=3)
fetch(url, retries=5)

\B[...] and \B{...} are the other bracket kinds, @block a balanced brace group and @nesting a group of any kind.

The groups that hold something

~#(A), written where a group opens, holds when A matches somewhere inside that group, and !~#(A) when it matches nowhere, however deep:

$ trex scan '\W ~#(\N{>=5}) \B(.*)' calls.py
[54..95] "retry(fetch(url, retries=5), backoff=2.5)"

$ trex scan '\W !~#("retries") \B(.*)' calls.py
[41..53] "save(record)"

let code = "log(fetch(url, retries=3), level=\"info\")\nsave(record)\nretry(fetch(url, retries=5), backoff=2.5)\n";
let found = |src: &str| -> Vec<&str> {
    let pat = trex::parse(src).expect("valid pattern");
    trex::scan(&pat, code.as_bytes()).iter().map(|s| &code[s.range()]).collect()
};
assert_eq!(found(r"\W ~#(\N{>=5}) \B(.*)"), ["retry(fetch(url, retries=5), backoff=2.5)"]);
assert_eq!(found(r#"\W !~#("retries") \B(.*)"#), ["save(record)"]);

>>> [m.text for m in trex.Pattern(r"\W ~#(\N{>=5}) \B(.*)").scan(code)]
['retry(fetch(url, retries=5), backoff=2.5)']
>>> [m.text for m in trex.Pattern(r'\W !~#("retries") \B(.*)').scan(code)]
['save(record)']

~#{m,n}(A) asks for between m and n places inside the group where A starts a match.

A name bound inside one group

A::name binds a register for the rest of the enclosing balanced group and drops it at the group’s close, so a back-reference to it never reaches past the group. A key repeated inside one object:

$ trex scan '\B{ .* \Q::k ":" .* =k ":" .* }' keys.json
[1..34] "{\"id\": 1, \"name\": \"ann\", \"id\": 7}"  captures: k=""

let json = r#"[{"id": 1, "name": "ann", "id": 7}, {"id": 2, "name": "bob"}, {"name": "cy", "id": 3}]"#;
let pat = trex::parse(r#"\B{ .* \Q::k ":" .* =k ":" .* }"#).expect("valid pattern");
let found: Vec<&str> = trex::scan(&pat, json.as_bytes()).iter().map(|s| &json[s.range()]).collect();
assert_eq!(found, [r#"{"id": 1, "name": "ann", "id": 7}"#]);

The binding is dropped when its group closes, so the match reports k empty. A plain \Q:k outside a group reaches across objects instead, from the first "id" to one in the third object:

$ trex scan '\Q:k ":" .* =k ":"' keys.json
[2..82] "\"id\": 1, \"name\": \"ann\", \"id\": 7}, {\"id\": 2, \"name\": \"bob\"}, {\"name\": \"cy\", \"id\":"  captures: k="\"id\""

let json = r#"[{"id": 1, "name": "ann", "id": 7}, {"id": 2, "name": "bob"}, {"name": "cy", "id": 3}]"#;
let pat = trex::parse(r#"\Q:k ":" .* =k ":""#).expect("valid pattern");
let m = &trex::captures(&pat, json.as_bytes(), &trex::scan(&pat, json.as_bytes()))[0];
assert_eq!((m.start, m.end, m.group("k", json.as_bytes())), (2, 82, Some(&br#""id""#[..])));

Filter by typed values Scan many patterns at once