Implement :hook filter

Change: hook-filter

Author: christian-schilling

josh-core/src/cache.rs

@@ -2,6 +2,10 @@ use super::*;
 use std::collections::HashMap;
 use std::sync::{LazyLock, RwLock};
 
+pub trait FilterHook {
+    fn filter_for_commit(&self, commit_oid: git2::Oid, arg: &str) -> JoshResult<filter::Filter>;
+}
+
 const CACHE_VERSION: u64 = 24;
 
 fn josh_commit_signature<'a>() -> JoshResult<git2::Signature<'a>> {
@@ -117,6 +121,7 @@ pub struct Transaction {
     t2: std::cell::RefCell<Transaction2>,
     repo: git2::Repository,
     ref_prefix: String,
+    filter_hook: Option<std::sync::Arc<dyn FilterHook + Send + Sync>>,
 }
 
 impl Transaction {
@@ -190,6 +195,7 @@ impl Transaction {
             }),
             repo,
             ref_prefix: ref_prefix.unwrap_or("").to_string(),
+            filter_hook: None,
         }
     }
 
@@ -363,6 +369,18 @@ impl Transaction {
         None
     }
 
+    pub fn lookup_filter_hook(&self, hook: &str, from: git2::Oid) -> JoshResult<filter::Filter> {
+        if let Some(h) = &self.filter_hook {
+            return h.filter_for_commit(from, hook);
+        }
+        Err(josh_error("missing filter hook"))
+    }
+
+    pub fn with_filter_hook(mut self, hook: std::sync::Arc<dyn FilterHook + Send + Sync>) -> Self {
+        self.filter_hook = Some(hook);
+        self
+    }
+
     pub fn insert(&self, filter: filter::Filter, from: git2::Oid, to: git2::Oid, store: bool) {
         let mut t2 = self.t2.borrow_mut();
         t2.commit_map

josh-core/src/filter/mod.rs

@@ -197,6 +197,10 @@ pub fn message(m: &str) -> Filter {
     to_filter(Op::Message(m.to_string()))
 }
 
+pub fn hook(h: &str) -> Filter {
+    to_filter(Op::Hook(h.to_string()))
+}
+
 pub fn squash(ids: Option<&[(git2::Oid, Filter)]>) -> Filter {
     if let Some(ids) = ids {
         to_filter(Op::Squash(Some(
@@ -276,6 +280,8 @@ enum Op {
 
     RegexReplace(Vec<(regex::Regex, String)>),
 
+    Hook(String),
+
     Index,
     Invert,
 
@@ -388,6 +394,7 @@ fn nesting2(op: &Op) -> usize {
         Op::Compose(filters) => 1 + filters.iter().map(|f| nesting(*f)).fold(0, |a, b| a.max(b)),
         Op::Exclude(filter) => 1 + nesting(*filter),
         Op::Workspace(_) => usize::MAX / 2, // divide by 2 to make sure there is enough headroom to avoid overflows
+        Op::Hook(_) => usize::MAX / 2, // divide by 2 to make sure there is enough headroom to avoid overflows
         Op::Chain(a, b) => 1 + nesting(*a).max(nesting(*b)),
         Op::Subtract(a, b) => 1 + nesting(*a).max(nesting(*b)),
         Op::Rev(filters) => {
@@ -629,6 +636,9 @@ fn spec2(op: &Op) -> String {
         Op::Message(m) => {
             format!(":{}", parse::quote(m))
         }
+        Op::Hook(hook) => {
+            format!(":hook={}", parse::quote(hook))
+        }
     }
 }
 
@@ -1063,6 +1073,51 @@ fn apply_to_commit2(
             let filtered_tree = repo.find_tree(filtered_tree)?;
             Apply::from_commit(commit)?.with_tree(filtered_tree)
         }
+        Op::Hook(hook) => {
+            let commit_filter = transaction.lookup_filter_hook(&hook, commit.id())?;
+            let normal_parents = commit
+                .parent_ids()
+                .map(|x| transaction.get(filter, x))
+                .collect::<Option<Vec<_>>>();
+            let normal_parents = some_or!(normal_parents, { return Ok(None) });
+
+            let extra_parents = commit
+                .parents()
+                .map(|parent| {
+                    rs_tracing::trace_scoped!("hook parent", "id": parent.id().to_string());
+
+                    let pcw = transaction.lookup_filter_hook(&hook, parent.id())?;
+                    let f = opt::optimize(to_filter(Op::Subtract(commit_filter, pcw)));
+
+                    let r = apply_to_commit2(&to_op(f), &parent, transaction);
+                    r
+                })
+                .collect::<JoshResult<Option<Vec<_>>>>()?;
+
+            let extra_parents = some_or!(extra_parents, { return Ok(None) });
+
+            let extra_parents: Vec<_> = extra_parents
+                .into_iter()
+                .filter(|&oid| oid != git2::Oid::zero())
+                .collect();
+
+            let filtered_parent_ids: Vec<_> =
+                normal_parents.into_iter().chain(extra_parents).collect();
+
+            let tree_data = apply(
+                transaction,
+                commit_filter,
+                Apply::from_commit(commit)?.with_parents(filtered_parent_ids.clone()),
+            )?;
+            return Some(history::create_filtered_commit(
+                commit,
+                filtered_parent_ids,
+                tree_data,
+                transaction,
+                filter,
+            ))
+            .transpose();
+        }
         _ => {
             let filtered_parent_ids = commit
                 .parent_ids()
@@ -1238,6 +1293,7 @@ fn apply2<'a>(transaction: &'a cache::Transaction, op: &Op, x: Apply<'a>) -> Jos
         Op::Chain(a, b) => {
             return apply(transaction, *b, apply(transaction, *a, x.clone())?);
         }
+        Op::Hook(_) => Err(josh_error("not applicable to tree")),
     }
 }
 

josh-core/src/filter/parse.rs

@@ -56,6 +56,7 @@ fn make_op(args: &[&str]) -> JoshResult<Op> {
         ["INDEX"] => Ok(Op::Index),
         ["INVERT"] => Ok(Op::Invert),
         ["FOLD"] => Ok(Op::Fold),
+        ["hook", arg] => Ok(Op::Hook(arg.to_string())),
         _ => Err(josh_error(
             formatdoc!(
                 r#"

josh-filter/src/bin/josh-filter.rs

@@ -127,6 +127,32 @@ fn make_app() -> clap::Command {
         .arg(clap::Arg::new("version").action(clap::ArgAction::SetTrue).long("version").short('v'))
 }
 
+struct GitNotesFilterHook {
+    repo: std::sync::Mutex<git2::Repository>,
+}
+
+impl josh::cache::FilterHook for GitNotesFilterHook {
+    fn filter_for_commit(
+        &self,
+        commit_oid: git2::Oid,
+        arg: &str,
+    ) -> josh::JoshResult<josh::filter::Filter> {
+        let notes_ref = if arg.starts_with("refs/") {
+            arg.to_string()
+        } else {
+            format!("refs/notes/{}", arg)
+        };
+        let repo = self.repo.lock().unwrap();
+        let note = repo
+            .find_note(Some(notes_ref.as_str()), commit_oid)
+            .map_err(|_| josh::josh_error("missing git note for commit"))?;
+        let msg = note
+            .message()
+            .ok_or_else(|| josh::josh_error("empty git note"))?;
+        josh::filter::parse(msg)
+    }
+}
+
 fn run_filter(args: Vec<String>) -> josh::JoshResult<i32> {
     let args = make_app().get_matches_from(args);
 
@@ -146,7 +172,16 @@ fn run_filter(args: Vec<String>) -> josh::JoshResult<i32> {
 
     let mut filterobj = josh::filter::parse(&specstr)?;
 
-    let transaction = josh::cache::Transaction::open_from_env(!args.get_flag("no-cache"))?;
+    let mut transaction = josh::cache::Transaction::open_from_env(!args.get_flag("no-cache"))?;
+    let repo_for_hook = git2::Repository::open_ext(
+        transaction.repo().path(),
+        git2::RepositoryOpenFlags::NO_SEARCH,
+        &[] as &[&std::ffi::OsStr],
+    )?;
+    let hook = GitNotesFilterHook {
+        repo: std::sync::Mutex::new(repo_for_hook),
+    };
+    transaction = transaction.with_filter_hook(std::sync::Arc::new(hook));
 
     let repo = transaction.repo();
     let input_ref = args.get_one::<String>("input").unwrap();

tests/filter/hook_notes.t

@@ -0,0 +1,35 @@
+  $ git init -q 1> /dev/null
+
+  $ mkdir a
+  $ mkdir b
+  $ mkdir c
+  $ echo a > a/f
+  $ echo b > b/g
+  $ echo c > c/h
+  $ git add .
+  $ git commit -m init 1> /dev/null
+  $ git notes add -m '::a' -f
+
+  $ echo a > a/f2
+  $ echo b > b/g2
+  $ git add .
+  $ git commit -m "add f2" 1> /dev/null
+  $ git notes add -m '::a' -f
+
+  $ echo a > c/f3
+  $ git add .
+  $ git commit -m "add f3" 1> /dev/null
+  $ git notes add -m ':[::a,::b]' -f
+
+
+  $ josh-filter -s :hook=commits HEAD --update refs/josh/filtered
+  [2] ::b
+  [3] :hook="commits"
+
+  $ git log --graph --pretty=%s refs/josh/filtered
+  *   add f3
+  |\  
+  | * add f2
+  | * init
+  * add f2
+  * init