hooks.rs 93.9%

93 of 99 lines run, 56 of 76 functions · run #351 on main · run missed

//! Client hooks (spec §20): executables in `.oxy/hooks/<event>`, never
//! cloned. Each receives one JSON object on stdin; `pre-*` hooks block the
//! operation by exiting non-zero, and their stderr becomes the error. The
//! `semantic-deps` hook runs only when `hooks.semantic-deps = true` and
//! answers `{"deps": ["<hash hex>", ...]}`.

use super::*;
use std::process::{Command, Stdio};

/// Minimal JSON string escaping.
pub fn json_str(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 2);
    out.push('"');
    for c in s.chars() {
        match c {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
            c => out.push(c),
        }
    }
    out.push('"');
    out
}

pub fn json_array<I: IntoIterator<Item = String>>(items: I) -> String {
    format!("[{}]", items.into_iter().collect::<Vec<_>>().join(","))
}

/// What running a hook produced.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HookOutcome {
    pub ran: bool,
    pub stdout: String,
}

impl Repo {
    fn hook_path(&self, event: &str) -> PathBuf {
        self.oxy.join("hooks").join(event)
    }

    /// Run the hook for `event` with `input` on stdin, if one exists and is
    /// executable. A non-zero exit is an error carrying the hook's stderr.
    pub fn run_hook(&self, event: &str, input: &str) -> Result<HookOutcome> {
        let path = self.hook_path(event);
        if !path.is_file() {
            return Ok(HookOutcome {
                ran: false,
                stdout: String::new(),
            });
        }
        let mut child = Command::new(&path)
            .current_dir(&self.root)
            .env("OXY_EVENT", event)
            .env("OXY_ROOT", &self.root)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .map_err(|e| RepoError::Msg(format!("running hook {event}: {e}")))?;
        if let Some(mut stdin) = child.stdin.take() {
            let _ = stdin.write_all(input.as_bytes());
        }
        let out = child.wait_with_output()?;
        let stdout = String::from_utf8_lossy(&out.stdout).to_string();
        if !out.status.success() {
            let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
            return fail(format!(
                "hook {event} refused: {}",
                if stderr.is_empty() {
                    "(no message)".to_string()
                } else {
                    stderr
                }
            ));
        }
        Ok(HookOutcome { ran: true, stdout })
    }

    /// Extra dependencies from the `semantic-deps` hook (spec §8.1, §20).
    pub(crate) fn semantic_deps(
        &self,
        change_id: &ChangeId,
        touched: &[String],
        candidates: &[(ChangeId, ChangeHash, Vec<String>)],
    ) -> Result<Vec<ChangeHash>> {
        if !self.config.semantic_deps {
            return Ok(vec![]);
        }
        let input = format!(
            "{{\"change_id\":{},\"touched_paths\":{},\"candidate_deps\":{}}}",
            json_str(&change_id.to_hex()),
            json_array(touched.iter().map(|p| json_str(p))),
            json_array(candidates.iter().map(|(id, h, paths)| format!(
                "{{\"change_id\":{},\"hash\":{},\"paths\":{}}}",
                json_str(&id.to_hex()),
                json_str(&h.to_hex()),
                json_array(paths.iter().map(|p| json_str(p)))
            )))
        );
        let out = self.run_hook("semantic-deps", &input)?;
        if !out.ran {
            return Ok(vec![]);
        }
        // Accept every 64-hex token after "deps"; any other shape is ignored.
        let body = out
            .stdout
            .split_once("\"deps\"")
            .map(|(_, rest)| rest.to_string())
            .unwrap_or_default();
        let mut deps = Vec::new();
        let bytes = body.as_bytes();
        let mut i = 0;
        while i + 64 <= bytes.len() {
            if bytes[i..i + 64].iter().all(|b| b.is_ascii_hexdigit())
                && (i == 0 || !bytes[i - 1].is_ascii_hexdigit())
                && (i + 64 == bytes.len() || !bytes[i + 64].is_ascii_hexdigit())
            {
                if let Some(h) = ObjectRef::from_hex(&body[i..i + 64]) {
                    deps.push(h);
                }
                i += 64;
            } else {
                i += 1;
            }
        }
        Ok(deps)
    }
}

1		//! Client hooks (spec §20): executables in `.oxy/hooks/<event>`, never
2		//! cloned. Each receives one JSON object on stdin; `pre-*` hooks block the
3		//! operation by exiting non-zero, and their stderr becomes the error. The
4		//! `semantic-deps` hook runs only when `hooks.semantic-deps = true` and
5		//! answers `{"deps": ["<hash hex>", ...]}`.
6
7		use super::*;
8		use std::process::{Command, Stdio};
9
10		/// Minimal JSON string escaping.
11	14295×	pub fn json_str(s: &str) -> String {
12	14295×	let mut out = String::with_capacity(s.len() + 2);
13	14295×	out.push('"');
14	280978×	for c in s.chars() {
15	280944×	match c {
16	5×	'"' => out.push_str("\\\""),
17	1×	'\\' => out.push_str("\\\\"),
18	28×	'\n' => out.push_str("\\n"),
19	0×	'\r' => out.push_str("\\r"),
20	0×	'\t' => out.push_str("\\t"),
21	280944×	c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
22	280944×	c => out.push(c),
23		}
24		}
25	14295×	out.push('"');
26	14295×	out
27	14295×	}
28
29	2416×	pub fn json_array<I: IntoIterator<Item = String>>(items: I) -> String {
30	2416×	format!("[{}]", items.into_iter().collect::<Vec<_>>().join(","))
31	2416×	}
32
33		/// What running a hook produced.
34		#[derive(Debug, Clone, PartialEq, Eq)]
35		pub struct HookOutcome {
36		pub ran: bool,
37		pub stdout: String,
38		}
39
40		impl Repo {
41	2606×	fn hook_path(&self, event: &str) -> PathBuf {
42	2606×	self.oxy.join("hooks").join(event)
43	2606×	}
44
45		/// Run the hook for `event` with `input` on stdin, if one exists and is
46		/// executable. A non-zero exit is an error carrying the hook's stderr.
47	2606×	pub fn run_hook(&self, event: &str, input: &str) -> Result<HookOutcome> {
48	2606×	let path = self.hook_path(event);
49	2606×	if !path.is_file() {
50	2596×	return Ok(HookOutcome {
51	2596×	ran: false,
52	2596×	stdout: String::new(),
53	2596×	});
54	10×	}
55	10×	let mut child = Command::new(&path)
56	10×	.current_dir(&self.root)
57	10×	.env("OXY_EVENT", event)
58	10×	.env("OXY_ROOT", &self.root)
59	10×	.stdin(Stdio::piped())
60	10×	.stdout(Stdio::piped())
61	10×	.stderr(Stdio::piped())
62	10×	.spawn()
63	10×	.map_err(\|e\| RepoError::Msg(format!("running hook {event}: {e}")))?;
64	10×	if let Some(mut stdin) = child.stdin.take() {
65	10×	let _ = stdin.write_all(input.as_bytes());
66	10×	}
67	10×	let out = child.wait_with_output()?;
68	10×	let stdout = String::from_utf8_lossy(&out.stdout).to_string();
69	10×	if !out.status.success() {
70	2×	let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
71	2×	return fail(format!(
72		"hook {event} refused: {}",
73	2×	if stderr.is_empty() {
74	0×	"(no message)".to_string()
75		} else {
76	2×	stderr
77		}
78		));
79	8×	}
80	8×	Ok(HookOutcome { ran: true, stdout })
81	2606×	}
82
83		/// Extra dependencies from the `semantic-deps` hook (spec §8.1, §20).
84	1×	pub(crate) fn semantic_deps(
85	1×	&self,
86	1×	change_id: &ChangeId,
87	1×	touched: &[String],
88	1×	candidates: &[(ChangeId, ChangeHash, Vec<String>)],
89	1×	) -> Result<Vec<ChangeHash>> {
90	1×	if !self.config.semantic_deps {
91	0×	return Ok(vec![]);
92	1×	}
93	1×	let input = format!(
94		"{{\"change_id\":{},\"touched_paths\":{},\"candidate_deps\":{}}}",
95	1×	json_str(&change_id.to_hex()),
96	1×	json_array(touched.iter().map(\|p\| json_str(p))),
97	2×	json_array(candidates.iter().map(\|(id, h, paths)\| format!(
98		"{{\"change_id\":{},\"hash\":{},\"paths\":{}}}",
99	2×	json_str(&id.to_hex()),
100	2×	json_str(&h.to_hex()),
101	3×	json_array(paths.iter().map(\|p\| json_str(p)))
102		)))
103		);
104	1×	let out = self.run_hook("semantic-deps", &input)?;
105	1×	if !out.ran {
106	0×	return Ok(vec![]);
107	1×	}
108		// Accept every 64-hex token after "deps"; any other shape is ignored.
109	1×	let body = out
110	1×	.stdout
111	1×	.split_once("\"deps\"")
112	1×	.map(\|(_, rest)\| rest.to_string())
113	1×	.unwrap_or_default();
114	1×	let mut deps = Vec::new();
115	1×	let bytes = body.as_bytes();
116	1×	let mut i = 0;
117	6×	while i + 64 <= bytes.len() {
118	68×	if bytes[i..i + 64].iter().all(\|b\| b.is_ascii_hexdigit())
119	1×	&& (i == 0 \|\| !bytes[i - 1].is_ascii_hexdigit())
120	1×	&& (i + 64 == bytes.len() \|\| !bytes[i + 64].is_ascii_hexdigit())
121		{
122	1×	if let Some(h) = ObjectRef::from_hex(&body[i..i + 64]) {
123	1×	deps.push(h);
124	1×	}
125	1×	i += 64;
126	4×	} else {
127	4×	i += 1;
128	4×	}
129		}
130	1×	Ok(deps)
131	1×	}
132		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/oxy-core/src/repo/hooks.rs 93.9%

Keyboard