Add regex support to commit message filter

Author: christian-schilling

Cargo.lock

@@ -121,6 +121,34 @@ tree.
 Normally Josh will keep all commits in the filtered history whose tree differs from any of it's
 parents.
 
+### Commit message rewriting **`:"template"`** or **`:"template";"regex"`**
+
+Rewrite commit messages using a template string. The template can use regex capture groups
+to extract and reformat parts of the original commit message.
+
+**Simple message replacement:**
+```
+:"New message"
+```
+This replaces all commit messages with "New message".
+
+**Using regex with named capture groups:**
+```
+:"[{type}] {message}";"(?s)^(?P<type>fix|feat|docs): (?P<message>.+)$"
+```
+This uses a regex to match the original commit message and extract named capture groups (`{type}` and `{message}`)
+which are then used in the template. The regex `(?s)^(?P<type>fix|feat|docs): (?P<message>.+)$` matches
+commit messages starting with "fix:", "feat:", or "docs:" followed by a message, and the template
+reformats them as `[type] message`.
+
+**Removing text from messages:**
+```
+:"";"TODO"
+```
+This removes all occurrences of "TODO" from commit messages by matching "TODO" and replacing it with an empty string.
+The regex pattern can use `(?s)` to enable dot-all mode (so `.` matches newlines), allowing it to work with
+multi-line commit messages that include both a subject line and a body.
+
 ### Pin tree contents
 
 Pin revision of a subtree to revision of the parent commit.

docs/src/reference/filters.md

@@ -40,7 +40,7 @@ filter_nop = { CMD_START ~ "/" }
 filter_presub = { CMD_START ~ ":" ~ argument }
 filter = { CMD_START ~ cmd ~ "=" ~ (argument ~ (";" ~ argument)*)? }
 filter_noarg = { CMD_START ~ cmd }
-filter_message = { CMD_START ~ string }
+filter_message = { CMD_START ~ string ~ (";" ~ string)? }
 
 filter_rev = {
     CMD_START ~ "rev" ~ "("

josh-core/src/filter/grammar.pest

@@ -23,6 +23,12 @@ lazy_static! {
         std::sync::Mutex::new(std::collections::HashMap::new());
 }
 
+lazy_static! {
+    /// Match-all regex pattern used as the default for Op::Message when no regex is specified.
+    /// The pattern `(?s)^.*$` matches any string (including newlines) from start to end.
+    static ref MESSAGE_MATCH_ALL_REGEX: regex::Regex = regex::Regex::new("(?s)^.*$").unwrap();
+}
+
 /// Filters are represented as `git2::Oid`, however they are not ever stored
 /// inside the repo.
 #[derive(
@@ -69,6 +75,7 @@ impl std::fmt::Debug for Filter {
 #[derive(Debug)]
 pub struct Apply<'a> {
     tree: git2::Tree<'a>,
+    commit: git2::Oid,
     pub author: Option<(String, String)>,
     pub committer: Option<(String, String)>,
     pub message: Option<String>,
@@ -78,6 +85,7 @@ impl<'a> Clone for Apply<'a> {
     fn clone(&self) -> Self {
         Apply {
             tree: self.tree.clone(),
+            commit: self.commit.clone(),
             author: self.author.clone(),
             committer: self.committer.clone(),
             message: self.message.clone(),
@@ -90,6 +98,7 @@ impl<'a> Apply<'a> {
         Apply {
             tree,
             author: None,
+            commit: git2::Oid::zero(),
             committer: None,
             message: None,
         }
@@ -104,6 +113,7 @@ impl<'a> Apply<'a> {
         Apply {
             tree,
             author,
+            commit: git2::Oid::zero(),
             committer,
             message,
         }
@@ -125,6 +135,7 @@ impl<'a> Apply<'a> {
 
         Ok(Apply {
             tree,
+            commit: commit.id(),
             author,
             committer,
             message,
@@ -135,6 +146,7 @@ impl<'a> Apply<'a> {
         Apply {
             tree: self.tree,
             author: Some(author),
+            commit: self.commit,
             committer: self.committer,
             message: self.message,
         }
@@ -144,6 +156,7 @@ impl<'a> Apply<'a> {
         Apply {
             tree: self.tree,
             author: self.author,
+            commit: self.commit,
             committer: Some(committer),
             message: self.message,
         }
@@ -153,15 +166,27 @@ impl<'a> Apply<'a> {
         Apply {
             tree: self.tree,
             author: self.author,
+            commit: self.commit,
             committer: self.committer,
             message: Some(message),
         }
     }
 
+    pub fn with_commit(self, commit: git2::Oid) -> Self {
+        Apply {
+            tree: self.tree,
+            author: self.author,
+            commit: commit,
+            committer: self.committer,
+            message: self.message,
+        }
+    }
+
     pub fn with_tree(self, tree: git2::Tree<'a>) -> Self {
         Apply {
             tree,
             author: self.author,
+            commit: self.commit,
             committer: self.committer,
             message: self.message,
         }
@@ -185,7 +210,7 @@ pub fn empty() -> Filter {
 }
 
 pub fn message(m: &str) -> Filter {
-    to_filter(Op::Message(m.to_string()))
+    to_filter(Op::Message(m.to_string(), MESSAGE_MATCH_ALL_REGEX.clone()))
 }
 
 pub fn hook(h: &str) -> Filter {
@@ -285,7 +310,7 @@ enum Op {
     Workspace(std::path::PathBuf),
 
     Pattern(String),
-    Message(String),
+    Message(String, regex::Regex),
 
     Compose(Vec<Filter>),
     Chain(Filter, Filter),
@@ -609,9 +634,12 @@ fn spec2(op: &Op) -> String {
                 parse::quote(email)
             )
         }
-        Op::Message(m) => {
+        Op::Message(m, r) if r.as_str() == MESSAGE_MATCH_ALL_REGEX.as_str() => {
             format!(":{}", parse::quote(m))
         }
+        Op::Message(m, r) => {
+            format!(":{};{}", parse::quote(m), parse::quote(r.as_str()))
+        }
         Op::Hook(hook) => {
             format!(":hook={}", parse::quote(hook))
         }
@@ -1069,14 +1097,27 @@ fn apply2<'a>(transaction: &'a cache::Transaction, op: &Op, x: Apply<'a>) -> Jos
         Op::Squash(None) => Ok(x),
         Op::Author(author, email) => Ok(x.with_author((author.clone(), email.clone()))),
         Op::Committer(author, email) => Ok(x.with_committer((author.clone(), email.clone()))),
-        Op::Message(m) => Ok(x.with_message(
-            // Pass the message through `strfmt` to enable future extensions
-            strfmt::strfmt(
-                m,
-                &std::collections::HashMap::<String, &dyn strfmt::DisplayStr>::new(),
-            )?,
-        )),
         Op::Squash(Some(_)) => Err(josh_error("not applicable to tree")),
+        Op::Message(m, r) => {
+            let tree_id = x.tree().id().to_string();
+            let commit = x.commit;
+            let commit_id = commit.to_string();
+            let mut hm = std::collections::HashMap::<String, String>::new();
+            hm.insert("tree".to_string(), tree_id);
+            hm.insert("commit".to_string(), commit_id);
+
+            let message = if let Some(ref m) = x.message {
+                m.to_string()
+            } else {
+                if let Ok(c) = transaction.repo().find_commit(commit) {
+                    c.message_raw().unwrap_or_default().to_string()
+                } else {
+                    "".to_string()
+                }
+            };
+
+            Ok(x.with_message(text::transform_with_template(&r, &m, &message, &hm)?))
+        }
         Op::Linear => Ok(x),
         Op::Prune => Ok(x),
         Op::Unsign => Ok(x),

josh-core/src/filter/mod.rs

@@ -105,7 +105,14 @@ fn parse_item(pair: pest::iterators::Pair<Rule>) -> JoshResult<Op> {
         }
         Rule::filter_message => {
             let mut inner = pair.into_inner();
-            Ok(Op::Message(unquote(inner.next().unwrap().as_str())))
+            let fmt = unquote(inner.next().unwrap().as_str());
+            let regex = if let Some(r) = inner.next() {
+                regex::Regex::new(&unquote(r.as_str()))
+                    .map_err(|e| josh_error(&format!("invalid regex: {}", e)))?
+            } else {
+                super::MESSAGE_MATCH_ALL_REGEX.clone()
+            };
+            Ok(Op::Message(fmt, regex))
         }
         Rule::filter_group => {
             let v: Vec<_> = pair.into_inner().map(|x| unquote(x.as_str())).collect();

josh-core/src/filter/parse.rs

@@ -165,6 +165,10 @@ impl InMemoryBuilder {
         let mut entries = Vec::new();
 
         match op {
+            Op::Message(fmt, regex) => {
+                let params_tree = self.build_str_params(&[fmt, regex.as_str()]);
+                push_tree_entries(&mut entries, [("message", params_tree)]);
+            }
             Op::Author(name, email) => {
                 let params_tree = self.build_str_params(&[name, email]);
                 push_tree_entries(&mut entries, [("author", params_tree)]);
@@ -209,10 +213,6 @@ impl InMemoryBuilder {
                 let blob = self.write_blob(pattern.as_bytes());
                 push_blob_entries(&mut entries, [("pattern", blob)]);
             }
-            Op::Message(m) => {
-                let blob = self.write_blob(m.as_bytes());
-                push_blob_entries(&mut entries, [("message", blob)]);
-            }
             Op::Workspace(path) => {
                 let blob = self.write_blob(path.to_string_lossy().as_bytes());
                 push_blob_entries(&mut entries, [("workspace", blob)]);
@@ -423,6 +423,26 @@ fn from_tree2(repo: &git2::Repository, tree_oid: git2::Oid) -> JoshResult<Op> {
             let email = std::str::from_utf8(email_blob.content())?.to_string();
             Ok(Op::Committer(name, email))
         }
+        "message" => {
+            let inner = repo.find_tree(entry.id())?;
+            let fmt_blob = repo.find_blob(
+                inner
+                    .get_name("0")
+                    .ok_or_else(|| josh_error("message: missing fmt string"))?
+                    .id(),
+            )?;
+            let regex_blob = repo.find_blob(
+                inner
+                    .get_name("1")
+                    .ok_or_else(|| josh_error("message: missing regex"))?
+                    .id(),
+            )?;
+            let fmt = std::str::from_utf8(fmt_blob.content())?.to_string();
+            let regex_str = std::str::from_utf8(regex_blob.content())?;
+            let regex = regex::Regex::new(regex_str)
+                .map_err(|e| josh_error(&format!("invalid regex: {}", e)))?;
+            Ok(Op::Message(fmt, regex))
+        }
         "subdir" => {
             let blob = repo.find_blob(entry.id())?;
             let path = std::str::from_utf8(blob.content())?;
@@ -443,11 +463,6 @@ fn from_tree2(repo: &git2::Repository, tree_oid: git2::Oid) -> JoshResult<Op> {
             let pattern = std::str::from_utf8(blob.content())?.to_string();
             Ok(Op::Pattern(pattern))
         }
-        "message" => {
-            let blob = repo.find_blob(entry.id())?;
-            let message = std::str::from_utf8(blob.content())?.to_string();
-            Ok(Op::Message(message))
-        }
         "workspace" => {
             let blob = repo.find_blob(entry.id())?;
             let path = std::str::from_utf8(blob.content())?;