feat: Ability to steer long running filter processes.

gix-filter/Cargo.toml

@@ -18,6 +18,7 @@ gix-object = { version = "^0.31.0", path = "../gix-object" }
 gix-command = { version = "^0.2.6", path = "../gix-command" }
 gix-quote = { version = "^0.4.5", path = "../gix-quote" }
 gix-path = { version = "^0.8.2", path = "../gix-path" }
+gix-packetline = { package = "gix-packetline-blocking", version = "^0.16.3", path = "../gix-packetline-blocking" }
 
 encoding_rs = "0.8.32"
 bstr = { version = "1.5.0", default-features = false, features = ["std"] }

gix-filter/examples/ident.rs

@@ -1,5 +1,7 @@
 use bstr::io::BufReadExt;
-use std::io::{stdin, stdout, Write};
+use bstr::{ByteSlice, ByteVec};
+use gix_filter::driver::process;
+use std::io::{stdin, stdout, Read, Write};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut args = std::env::args();
@@ -11,6 +13,60 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     match sub_command.as_str() {
+        "process" => {
+            let mut srv = gix_filter::driver::process::Server::handshake(
+                stdin(),
+                stdout(),
+                "git-filter",
+                |versions| versions.contains(&2).then_some(2),
+                &["clean", "smudge"],
+            )?;
+
+            loop {
+                let mut request = srv.next_request()?;
+                let needs_failure = request
+                    .meta
+                    .iter()
+                    .find_map(|(key, value)| (key == "pathname").then_some(value))
+                    .map_or(false, |path| path.ends_with(b"fail"));
+                if needs_failure {
+                    panic!("process failure requested: {:?}", request.meta);
+                }
+                match request.command.as_str() {
+                    "clean" => {
+                        let mut buf = Vec::new();
+                        request.as_read().read_to_end(&mut buf)?;
+                        request.write_status(process::Status::success())?;
+
+                        let mut lines = Vec::new();
+                        for mut line in buf.lines_with_terminator() {
+                            if line.starts_with(b"\t") {
+                                line = &line[1..];
+                            }
+                            lines.push_str(line);
+                        }
+                        request.as_write().write_all(&lines)?;
+                        request.write_status(process::Status::Previous)?;
+                    }
+                    "smudge" => {
+                        let mut buf = Vec::new();
+                        request.as_read().read_to_end(&mut buf)?;
+                        request.write_status(process::Status::success())?;
+
+                        let mut lines = Vec::new();
+                        for line in buf.lines_with_terminator() {
+                            if !line.starts_with(b"\t") {
+                                lines.push(b'\t');
+                            }
+                            lines.push_str(line);
+                        }
+                        request.as_write().write_all(&lines)?;
+                        request.write_status(process::Status::Previous)?;
+                    }
+                    unknown => panic!("Unknown capability requested: {unknown}"),
+                }
+            }
+        }
         "clean" => {
             let mut stdin = stdin().lock();
             let mut stdout = stdout().lock();