templates: add string.match function

This allows for any matcher type and allows extracting a capture group
by number.

Author: lf-

CHANGELOG.md

@@ -109,6 +109,9 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   output using template expressions, similar to `jj op log`. Also added
   `--no-op-diff` flag to suppress the operation diff.
 
+* A nearly identical string pattern system as revsets is now supported in the
+  template language, and is exposed as `string.match(pattern)`.
+
 ### Fixed bugs
 
 * `jj git clone` now correctly fetches all tags, unless `--fetch-tags` is

cli/src/template_builder.rs

@@ -909,6 +909,25 @@ fn builtin_string_methods<'a, L: TemplateLanguage<'a> + ?Sized>()
             Ok(out_property.into_dyn_wrapped())
         },
     );
+    map.insert(
+        "match",
+        |_language, _diagnostics, _build_ctx, self_property, function| {
+            let [needle_node] = function.expect_exact_arguments()?;
+            let needle = template_parser::expect_string_pattern(needle_node)?;
+            let regex = needle.to_regex();
+
+            let out_property = self_property.and_then(move |haystack| {
+                if let Some(m) = regex.find(haystack.as_bytes()) {
+                    Ok(std::str::from_utf8(m.as_bytes())?.to_owned())
+                } else {
+                    // We don't have optional strings, so empty string is the
+                    // right null value.
+                    Ok(String::new())
+                }
+            });
+            Ok(out_property.into_dyn_wrapped())
+        },
+    );
     map.insert(
         "starts_with",
         |language, diagnostics, build_ctx, self_property, function| {
@@ -2990,6 +3009,32 @@ mod tests {
         insta::assert_snapshot!(
             env.render_ok(r#""foo".contains(separate("o", "f", bad_string))"#), @"<Error: Bad>");
 
+        insta::assert_snapshot!(env.render_ok(r#""fooo".match(regex:'[a-f]o+')"#), @"fooo");
+        insta::assert_snapshot!(env.render_ok(r#""fa".match(regex:'[a-f]o+')"#), @"");
+        insta::assert_snapshot!(env.render_ok(r#""hello".match(regex:"h(ell)o")"#), @"hello");
+        insta::assert_snapshot!(env.render_ok(r#""HEllo".match(regex-i:"h(ell)o")"#), @"HEllo");
+        insta::assert_snapshot!(env.render_ok(r#""hEllo".match(glob:"h*o")"#), @"hEllo");
+        insta::assert_snapshot!(env.render_ok(r#""Hello".match(glob:"h*o")"#), @"");
+        insta::assert_snapshot!(env.render_ok(r#""HEllo".match(glob-i:"h*o")"#), @"HEllo");
+        insta::assert_snapshot!(env.render_ok(r#""hello".match("he")"#), @"he");
+        insta::assert_snapshot!(env.render_ok(r#""hello".match(substring:"he")"#), @"he");
+        insta::assert_snapshot!(env.render_ok(r#""hello".match(exact:"he")"#), @"");
+
+        // Evil regexes can cause invalid UTF-8 output, which nothing can
+        // really be done about given we're matching against non-UTF-8 stuff a
+        // lot as well.
+        insta::assert_snapshot!(env.render_ok(r#""🥺".match(regex:'(?-u)^(?:.)')"#), @"<Error: incomplete utf-8 byte sequence from index 0>");
+
+        insta::assert_snapshot!(env.parse_err(r#""🥺".match(not-a-pattern:"abc")"#), @r#"
+         --> 1:11
+          |
+        1 | "🥺".match(not-a-pattern:"abc")
+          |           ^-----------------^
+          |
+          = Bad string pattern
+        Invalid string pattern kind `not-a-pattern:`
+        "#);
+
         insta::assert_snapshot!(env.render_ok(r#""".first_line()"#), @"");
         insta::assert_snapshot!(env.render_ok(r#""foo\nbar".first_line()"#), @"foo");
 

docs/templates.md

@@ -426,6 +426,10 @@ defined.
 * `.len() -> Integer`: Length in UTF-8 bytes.
 * `.contains(needle: Stringify) -> Boolean`: Whether the string contains the
   provided stringifiable value as a substring.
+* `.match(needle: StringPattern) -> String`: Extracts
+  the matching part of the string for the given pattern.
+
+  An empty string is returned if there is no match.
 * `.first_line() -> String`
 * `.lines() -> List<String>`: Split into lines excluding newline characters.
 * `.upper() -> String`

lib/src/str_util.rs

@@ -60,6 +60,11 @@ impl GlobPattern {
     pub fn as_str(&self) -> &str {
         self.glob.glob()
     }
+
+    /// Converts this glob pattern to a bytes regex.
+    pub fn to_regex(&self) -> regex::bytes::Regex {
+        self.regex.clone()
+    }
 }
 
 impl Debug for GlobPattern {
@@ -289,6 +294,35 @@ impl StringPattern {
         }
     }
 
+    /// Converts the pattern into a bytes regex.
+    pub fn to_regex(&self) -> regex::bytes::Regex {
+        match self {
+            Self::Exact(literal) => {
+                regex::bytes::RegexBuilder::new(&format!("^{}$", regex::escape(literal)))
+                    .build()
+                    .expect("impossible to fail to compile regex of literal")
+            }
+            Self::ExactI(literal) => {
+                regex::bytes::RegexBuilder::new(&format!("^{}$", regex::escape(literal)))
+                    .case_insensitive(true)
+                    .build()
+                    .expect("impossible to fail to compile regex of literal")
+            }
+            Self::Substring(literal) => regex::bytes::RegexBuilder::new(&regex::escape(literal))
+                .build()
+                .expect("impossible to fail to compile regex of literal"),
+            Self::SubstringI(literal) => regex::bytes::RegexBuilder::new(&regex::escape(literal))
+                .case_insensitive(true)
+                .build()
+                .expect("impossible to fail to compile regex of literal"),
+            Self::Glob(glob_pattern) => glob_pattern.to_regex(),
+            // The regex generated represents the case insensitivity itself
+            Self::GlobI(glob_pattern) => glob_pattern.to_regex(),
+            Self::Regex(regex) => regex.clone(),
+            Self::RegexI(regex) => regex.clone(),
+        }
+    }
+
     /// Iterates entries of the given `map` whose string keys match this
     /// pattern.
     pub fn filter_btree_map<'a, 'b, K: Borrow<str> + Ord, V>(
@@ -487,4 +521,24 @@ mod tests {
                 .is_match("\u{c0}")
         );
     }
+
+    #[test]
+    fn test_string_pattern_to_regex() {
+        let check = |pattern: StringPattern, match_to: &str| {
+            let regex = pattern.to_regex();
+            regex.is_match(match_to.as_bytes())
+        };
+        assert!(check(StringPattern::exact("a"), "a"));
+        assert!(!check(StringPattern::exact("a"), "A"));
+        assert!(!check(StringPattern::exact("a"), "aa"));
+        assert!(check(StringPattern::exact_i("a"), "A"));
+        assert!(check(StringPattern::substring("a"), "abc"));
+        assert!(!check(StringPattern::substring("a"), "Abc"));
+        assert!(check(StringPattern::substring_i("a"), "Abc"));
+        assert!(!check(StringPattern::glob("a").unwrap(), "A"));
+        assert!(check(StringPattern::glob_i("a").unwrap(), "A"));
+        assert!(check(StringPattern::regex("^a{1,3}").unwrap(), "abcde"));
+        assert!(!check(StringPattern::regex("^a{1,3}").unwrap(), "Abcde"));
+        assert!(check(StringPattern::regex_i("^a{1,3}").unwrap(), "Abcde"));
+    }
 }