use std::path::Path;
use std::sync::OnceLock;
use parking_lot::RwLock;
use crate::worktree::ResolvedTarget;
#[derive(Debug, Clone, Copy)]
pub struct EditContext<'a> {
pub relative_path: &'a str,
pub indexed_absolute_path: &'a Path,
pub repo_root: &'a Path,
pub project_state_dir: Option<&'a crate::domain::ProjectStateDir>,
pub working_directory: Option<&'a Path>,
}
pub trait EditHook: Send + Sync {
fn resolve_target_path(&self, ctx: &EditContext) -> Result<ResolvedTarget, String> {
let abs = ctx.indexed_absolute_path.to_path_buf();
Ok(ResolvedTarget {
target_path: abs.clone(),
indexed_path: abs,
rerouted: false,
})
}
fn after_edit_committed(&self, _ctx: &EditContext, _resolved_path: &Path) {}
}
pub struct DefaultEditHook;
impl EditHook for DefaultEditHook {}
fn registry() -> &'static RwLock<Vec<Box<dyn EditHook>>> {
static REGISTRY: OnceLock<RwLock<Vec<Box<dyn EditHook>>>> = OnceLock::new();
REGISTRY.get_or_init(|| RwLock::new(vec![Box::new(DefaultEditHook) as Box<dyn EditHook>]))
}
pub fn register(hook: Box<dyn EditHook>) {
registry().write().push(hook);
}
pub fn resolve(ctx: &EditContext) -> Result<ResolvedTarget, String> {
crate::worktree::refuse_network_working_directories([ctx.working_directory])
.map_err(|error| error.to_string())?;
let reg = registry().read();
let mut passthrough: Option<ResolvedTarget> = None;
for hook in reg.iter().rev() {
let resolved = hook.resolve_target_path(ctx)?;
if resolved.rerouted {
return Ok(resolved);
}
if passthrough.is_none() {
passthrough = Some(resolved);
}
}
match passthrough {
Some(resolved) => Ok(resolved),
None => DefaultEditHook.resolve_target_path(ctx),
}
}
pub fn after_commit(ctx: &EditContext, resolved_path: &Path) {
let reg = registry().read();
for hook in reg.iter() {
hook.after_edit_committed(ctx, resolved_path);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
#[test]
fn default_hook_returns_indexed_path_unchanged() {
let repo_root = PathBuf::from("/tmp/repo");
let abs = repo_root.join("src/lib.rs");
let ctx = EditContext {
relative_path: "src/lib.rs",
indexed_absolute_path: &abs,
repo_root: &repo_root,
project_state_dir: None,
working_directory: None,
};
let resolved = DefaultEditHook.resolve_target_path(&ctx).expect("resolves");
assert_eq!(resolved.target_path, abs);
assert_eq!(resolved.indexed_path, abs);
assert!(!resolved.rerouted);
}
#[test]
fn default_hook_after_commit_is_noop() {
let repo_root = PathBuf::from("/tmp/repo");
let abs = repo_root.join("src/lib.rs");
let ctx = EditContext {
relative_path: "src/lib.rs",
indexed_absolute_path: &abs,
repo_root: &repo_root,
project_state_dir: None,
working_directory: None,
};
DefaultEditHook.after_edit_committed(&ctx, &abs);
}
#[test]
fn registry_resolves_via_default_when_only_default_registered() {
let repo_root = PathBuf::from("/tmp/repo-registry");
let abs = repo_root.join("src/lib.rs");
let ctx = EditContext {
relative_path: "src/lib.rs",
indexed_absolute_path: &abs,
repo_root: &repo_root,
project_state_dir: None,
working_directory: None,
};
let resolved = resolve(&ctx).expect("resolves");
assert_eq!(resolved.target_path, abs);
assert!(!resolved.rerouted);
}
#[test]
fn default_hook_ignores_working_directory() {
let repo_root = PathBuf::from("/tmp/repo");
let abs = repo_root.join("src/lib.rs");
let cwd = PathBuf::from("/tmp/some/worktree");
let ctx = EditContext {
relative_path: "src/lib.rs",
indexed_absolute_path: &abs,
repo_root: &repo_root,
project_state_dir: None,
working_directory: Some(&cwd),
};
let resolved = DefaultEditHook.resolve_target_path(&ctx).expect("resolves");
assert_eq!(resolved.target_path, abs);
assert!(!resolved.rerouted);
}
#[test]
fn resolve_prefers_active_reroute_over_later_passthrough_hook() {
const SENTINEL: &str = "F6_SENTINEL_REROUTE";
struct ReroutingHook;
impl EditHook for ReroutingHook {
fn resolve_target_path(&self, ctx: &EditContext) -> Result<ResolvedTarget, String> {
if ctx.relative_path == SENTINEL {
Ok(ResolvedTarget {
target_path: PathBuf::from("/worktree").join(ctx.relative_path),
indexed_path: ctx.indexed_absolute_path.to_path_buf(),
rerouted: true,
})
} else {
let abs = ctx.indexed_absolute_path.to_path_buf();
Ok(ResolvedTarget {
target_path: abs.clone(),
indexed_path: abs,
rerouted: false,
})
}
}
}
struct ObserverOnlyHook;
impl EditHook for ObserverOnlyHook {
fn after_edit_committed(&self, _ctx: &EditContext, _p: &Path) {}
}
register(Box::new(ReroutingHook));
register(Box::new(ObserverOnlyHook));
let repo_root = PathBuf::from("/repo");
let abs = repo_root.join(SENTINEL);
let ctx = EditContext {
relative_path: SENTINEL,
indexed_absolute_path: &abs,
repo_root: &repo_root,
project_state_dir: None,
working_directory: Some(Path::new("/worktree")),
};
let resolved = resolve(&ctx).expect("resolves");
assert!(
resolved.rerouted,
"an active reroute must win over a later observer-only passthrough hook"
);
assert_eq!(
resolved.target_path,
PathBuf::from("/worktree").join(SENTINEL)
);
}
}