templates: add string.match function

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

Author: lf-

CHANGELOG.md

@@ -57,6 +57,9 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 * Glob patterns now support `{foo,bar}` syntax. There may be subtle behavior
   changes as we use the [globset](https://crates.io/crates/globset) library now.
 
+* An identical string pattern system as revsets is now supported in the
+  template language, and is exposed as `string.match(pattern)`.
+
 ### Fixed bugs
 
 ### Packaging changes

cli/src/template_builder.rs

@@ -902,6 +902,28 @@ 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 out_property = self_property.and_then(move |haystack| {
+                let regex = needle.to_regex();
+                let match_ = regex.find(haystack.as_bytes());
+
+                if let Some(m) = match_ {
+                    Ok(String::from_utf8(m.as_bytes().to_owned())?)
+                } else {
+                    // FIXME(jade): maybe suboptimal to return string
+                    // unconditionally but we don't have an Option<String> type
+                    // yet.
+                    Ok(String::new())
+                }
+            });
+            Ok(out_property.into_dyn_wrapped())
+        },
+    );
     map.insert(
         "starts_with",
         |language, diagnostics, build_ctx, self_property, function| {
@@ -2804,6 +2826,35 @@ 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")"#), @"");
+
+        // NOTE: this is asserting that we are still parsing as string regex
+        // before reparsing as a bytes regex. We will plausibly stop doing that
+        // (https://github.com/jj-vcs/jj/pull/6899#discussion_r2214764968).
+        // If we stop doing that, this test should instead confirm that a bad
+        // regex still generates a good error when the invalid utf-8 is
+        // converted to a string.
+        insta::assert_snapshot!(env.parse_err(r#""🥺".match(regex:'^(?-u:.).+$')"#), @r#"
+         --> 1:11
+          |
+        1 | "🥺".match(regex:'^(?-u:.).+$')
+          |           ^-----------------^
+          |
+          = Bad string pattern: regex parse error:
+            ^(?-u:.).+$
+                  ^
+        error: pattern can match invalid UTF-8
+        "#);
+
         insta::assert_snapshot!(env.render_ok(r#""".first_line()"#), @"");
         insta::assert_snapshot!(env.render_ok(r#""foo\nbar".first_line()"#), @"foo");
 

docs/templates.md

@@ -406,6 +406,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) -> Boolean`: 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

@@ -59,6 +59,14 @@ impl GlobPattern {
     pub fn as_str(&self) -> &str {
         self.glob.glob()
     }
+
+    /// Converts to a bytes regex.
+    pub fn to_regex(&self) -> regex::bytes::Regex {
+        regex::bytes::RegexBuilder::new(self.glob.regex())
+            .dot_matches_new_line(true)
+            .build()
+            .expect("glob regex should be valid")
+    }
 }
 
 impl Debug for GlobPattern {
@@ -283,6 +291,44 @@ impl StringPattern {
         }
     }
 
+    /// Converts the pattern into a bytes regex.
+    pub fn to_regex(&self) -> regex::bytes::Regex {
+        match self {
+            StringPattern::Exact(literal) => {
+                regex::bytes::RegexBuilder::new(&format!("^{}$", regex::escape(literal)))
+                    .build()
+                    .expect("impossible to fail to compile regex of literal")
+            }
+            StringPattern::ExactI(literal) => {
+                regex::bytes::RegexBuilder::new(&format!("^{}$", regex::escape(literal)))
+                    .case_insensitive(true)
+                    .build()
+                    .expect("impossible to fail to compile regex of literal")
+            }
+            StringPattern::Substring(literal) => {
+                regex::bytes::RegexBuilder::new(&regex::escape(literal))
+                    .build()
+                    .expect("impossible to fail to compile regex of literal")
+            }
+            StringPattern::SubstringI(literal) => {
+                regex::bytes::RegexBuilder::new(&regex::escape(literal))
+                    .case_insensitive(true)
+                    .build()
+                    .expect("impossible to fail to compile regex of literal")
+            }
+            StringPattern::Glob(glob_pattern) => glob_pattern.to_regex(),
+            // The regex generated represents the case insensitivity itself
+            StringPattern::GlobI(glob_pattern) => glob_pattern.to_regex(),
+            StringPattern::Regex(regex) => regex::bytes::RegexBuilder::new(regex.as_str())
+                .build()
+                .expect("bytes regexes are a superset of unicode regexes"),
+            StringPattern::RegexI(regex) => regex::bytes::RegexBuilder::new(regex.as_str())
+                .case_insensitive(true)
+                .build()
+                .expect("bytes regexes are a superset of unicode regexes"),
+        }
+    }
+
     /// Iterates entries of the given `map` whose string keys match this
     /// pattern.
     pub fn filter_btree_map<'a, 'b, K: Borrow<str> + Ord, V>(