490 lines
14 KiB
Rust
490 lines
14 KiB
Rust
use std::path::{Path, PathBuf};
|
|
|
|
const DEFAULT_WORKTREE_PREFIX: &str = "worktree";
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub(crate) struct WorktreeCommand {
|
|
pub program: String,
|
|
pub args: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub(crate) struct ExistingWorktree {
|
|
pub path: PathBuf,
|
|
pub branch: Option<String>,
|
|
pub is_bare: bool,
|
|
pub is_detached: bool,
|
|
pub is_prunable: bool,
|
|
}
|
|
|
|
pub(crate) fn generated_branch_slug(seed: u64) -> String {
|
|
let adjectives = [
|
|
"brave", "calm", "clear", "green", "lucky", "quiet", "rapid", "silver",
|
|
];
|
|
let nouns = [
|
|
"river", "cloud", "field", "forest", "harbor", "meadow", "stone", "valley",
|
|
];
|
|
let adjective = adjectives[(seed as usize) % adjectives.len()];
|
|
let noun = nouns[((seed / adjectives.len() as u64) as usize) % nouns.len()];
|
|
let suffix = seed & 0xffff;
|
|
format!("{DEFAULT_WORKTREE_PREFIX}/{adjective}-{noun}-{suffix:04x}")
|
|
}
|
|
|
|
pub(crate) fn branch_to_path_slug(branch: &str) -> String {
|
|
let mut slug = String::new();
|
|
let mut last_was_dash = false;
|
|
|
|
for ch in branch.chars() {
|
|
if ch.is_ascii_alphanumeric() {
|
|
slug.push(ch.to_ascii_lowercase());
|
|
last_was_dash = false;
|
|
} else if !last_was_dash {
|
|
slug.push('-');
|
|
last_was_dash = true;
|
|
}
|
|
}
|
|
|
|
let trimmed = slug.trim_matches('-').to_string();
|
|
if trimmed.is_empty() {
|
|
DEFAULT_WORKTREE_PREFIX.to_string()
|
|
} else {
|
|
trimmed
|
|
}
|
|
}
|
|
|
|
pub(crate) fn expand_tilde_path(path: &str) -> PathBuf {
|
|
if path == "~" {
|
|
return std::env::var("HOME")
|
|
.map(PathBuf::from)
|
|
.unwrap_or_else(|_| PathBuf::from(path));
|
|
}
|
|
|
|
if let Some(rest) = path.strip_prefix("~/") {
|
|
return std::env::var("HOME")
|
|
.map(|home| PathBuf::from(home).join(rest))
|
|
.unwrap_or_else(|_| PathBuf::from(path));
|
|
}
|
|
|
|
PathBuf::from(path)
|
|
}
|
|
|
|
pub(crate) fn expand_tilde_absolute_path(path: &str) -> PathBuf {
|
|
let path = expand_tilde_path(path);
|
|
if path.is_absolute() {
|
|
path
|
|
} else {
|
|
std::env::current_dir()
|
|
.map(|cwd| cwd.join(&path))
|
|
.unwrap_or(path)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn canonical_or_original(path: &Path) -> PathBuf {
|
|
std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
|
|
}
|
|
|
|
pub(crate) fn default_checkout_path(root: &Path, repo_name: &str, branch: &str) -> PathBuf {
|
|
root.join(repo_name).join(branch_to_path_slug(branch))
|
|
}
|
|
|
|
pub(crate) fn build_worktree_remove_command(
|
|
repo_root: &Path,
|
|
path: &Path,
|
|
force: bool,
|
|
) -> WorktreeCommand {
|
|
let mut args = vec![
|
|
"-C".to_string(),
|
|
repo_root.display().to_string(),
|
|
"worktree".to_string(),
|
|
"remove".to_string(),
|
|
];
|
|
if force {
|
|
args.push("--force".to_string());
|
|
}
|
|
args.push(path.display().to_string());
|
|
|
|
WorktreeCommand {
|
|
program: "git".to_string(),
|
|
args,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_dirty_worktree_remove_error(message: &str) -> bool {
|
|
let lower = message.to_ascii_lowercase();
|
|
lower.contains("contains modified or untracked files")
|
|
&& lower.contains("use --force to delete it")
|
|
}
|
|
|
|
pub(crate) fn build_worktree_add_new_branch_command(
|
|
repo_root: &Path,
|
|
path: &Path,
|
|
branch: &str,
|
|
base: &str,
|
|
) -> WorktreeCommand {
|
|
WorktreeCommand {
|
|
program: "git".to_string(),
|
|
args: vec![
|
|
"-C".to_string(),
|
|
repo_root.display().to_string(),
|
|
"worktree".to_string(),
|
|
"add".to_string(),
|
|
"-b".to_string(),
|
|
branch.to_string(),
|
|
path.display().to_string(),
|
|
base.to_string(),
|
|
],
|
|
}
|
|
}
|
|
|
|
pub(crate) fn run_worktree_command(command: &WorktreeCommand) -> Result<(), String> {
|
|
let output = std::process::Command::new(&command.program)
|
|
.args(&command.args)
|
|
.output()
|
|
.map_err(|err| err.to_string())?;
|
|
|
|
if output.status.success() {
|
|
return Ok(());
|
|
}
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
|
|
let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
|
|
let message = if stderr.is_empty() { stdout } else { stderr };
|
|
Err(if message.is_empty() {
|
|
format!("{} failed with status {}", command.program, output.status)
|
|
} else {
|
|
message
|
|
})
|
|
}
|
|
|
|
pub(crate) fn parse_worktree_list_porcelain(output: &str) -> Vec<ExistingWorktree> {
|
|
let mut entries = Vec::new();
|
|
let mut path: Option<PathBuf> = None;
|
|
let mut branch = None;
|
|
let mut is_bare = false;
|
|
let mut is_detached = false;
|
|
let mut is_prunable = false;
|
|
|
|
let finish = |entries: &mut Vec<ExistingWorktree>,
|
|
path: &mut Option<PathBuf>,
|
|
branch: &mut Option<String>,
|
|
is_bare: &mut bool,
|
|
is_detached: &mut bool,
|
|
is_prunable: &mut bool| {
|
|
if let Some(path) = path.take() {
|
|
entries.push(ExistingWorktree {
|
|
path,
|
|
branch: branch.take(),
|
|
is_bare: *is_bare,
|
|
is_detached: *is_detached,
|
|
is_prunable: *is_prunable,
|
|
});
|
|
}
|
|
*is_bare = false;
|
|
*is_detached = false;
|
|
*is_prunable = false;
|
|
};
|
|
|
|
for line in output.lines() {
|
|
if line.trim().is_empty() {
|
|
finish(
|
|
&mut entries,
|
|
&mut path,
|
|
&mut branch,
|
|
&mut is_bare,
|
|
&mut is_detached,
|
|
&mut is_prunable,
|
|
);
|
|
continue;
|
|
}
|
|
if let Some(value) = line.strip_prefix("worktree ") {
|
|
path = Some(PathBuf::from(value));
|
|
} else if let Some(value) = line.strip_prefix("branch ") {
|
|
branch = Some(
|
|
value
|
|
.strip_prefix("refs/heads/")
|
|
.unwrap_or(value)
|
|
.to_string(),
|
|
);
|
|
} else if line == "detached" {
|
|
is_detached = true;
|
|
} else if line == "bare" {
|
|
is_bare = true;
|
|
} else if line.starts_with("prunable") {
|
|
is_prunable = true;
|
|
}
|
|
}
|
|
|
|
finish(
|
|
&mut entries,
|
|
&mut path,
|
|
&mut branch,
|
|
&mut is_bare,
|
|
&mut is_detached,
|
|
&mut is_prunable,
|
|
);
|
|
entries
|
|
}
|
|
|
|
pub(crate) fn list_existing_worktrees(repo_root: &Path) -> Result<Vec<ExistingWorktree>, String> {
|
|
let output = std::process::Command::new("git")
|
|
.arg("-C")
|
|
.arg(repo_root)
|
|
.args(["worktree", "list", "--porcelain"])
|
|
.output()
|
|
.map_err(|err| err.to_string())?;
|
|
|
|
if output.status.success() {
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
return Ok(parse_worktree_list_porcelain(&stdout));
|
|
}
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
|
|
Err(if stderr.is_empty() {
|
|
format!("git worktree list failed with status {}", output.status)
|
|
} else {
|
|
stderr
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn unique_temp_path(name: &str) -> PathBuf {
|
|
let nanos = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|d| d.as_nanos())
|
|
.unwrap_or(0);
|
|
std::env::temp_dir().join(format!("herdr-{name}-{}-{nanos}", std::process::id()))
|
|
}
|
|
|
|
fn run_git(repo: &Path, args: &[&str]) {
|
|
let status = std::process::Command::new("git")
|
|
.arg("-C")
|
|
.arg(repo)
|
|
.args(args)
|
|
.status()
|
|
.unwrap();
|
|
assert!(
|
|
status.success(),
|
|
"git command failed: git -C {} {}",
|
|
repo.display(),
|
|
args.join(" ")
|
|
);
|
|
}
|
|
|
|
fn create_committed_repo(name: &str) -> PathBuf {
|
|
let repo = unique_temp_path(name);
|
|
std::fs::create_dir_all(&repo).unwrap();
|
|
run_git(&repo, &["init", "--quiet"]);
|
|
run_git(&repo, &["config", "user.email", "herdr@example.invalid"]);
|
|
run_git(&repo, &["config", "user.name", "Herdr Test"]);
|
|
std::fs::write(repo.join("README.md"), "test\n").unwrap();
|
|
run_git(&repo, &["add", "README.md"]);
|
|
run_git(&repo, &["commit", "--quiet", "-m", "initial"]);
|
|
repo
|
|
}
|
|
|
|
#[test]
|
|
fn generated_branch_slug_is_worktree_namespaced_and_stable() {
|
|
assert_eq!(generated_branch_slug(0), "worktree/brave-river-0000");
|
|
assert_eq!(generated_branch_slug(9), "worktree/calm-cloud-0009");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_git_worktree_list_porcelain() {
|
|
let output = "\
|
|
worktree /repo/main
|
|
HEAD abc
|
|
branch refs/heads/main
|
|
|
|
worktree /repo/issue
|
|
HEAD def
|
|
branch refs/heads/worktree/issue
|
|
|
|
worktree /repo/detached
|
|
HEAD fed
|
|
detached
|
|
prunable stale
|
|
|
|
";
|
|
|
|
assert_eq!(
|
|
parse_worktree_list_porcelain(output),
|
|
vec![
|
|
ExistingWorktree {
|
|
path: PathBuf::from("/repo/main"),
|
|
branch: Some("main".into()),
|
|
is_bare: false,
|
|
is_detached: false,
|
|
is_prunable: false,
|
|
},
|
|
ExistingWorktree {
|
|
path: PathBuf::from("/repo/issue"),
|
|
branch: Some("worktree/issue".into()),
|
|
is_bare: false,
|
|
is_detached: false,
|
|
is_prunable: false,
|
|
},
|
|
ExistingWorktree {
|
|
path: PathBuf::from("/repo/detached"),
|
|
branch: None,
|
|
is_bare: false,
|
|
is_detached: true,
|
|
is_prunable: true,
|
|
},
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_to_path_slug_makes_branch_safe_folder_name() {
|
|
assert_eq!(
|
|
branch_to_path_slug("worktree/brave-river"),
|
|
"worktree-brave-river"
|
|
);
|
|
assert_eq!(
|
|
branch_to_path_slug("issue/137 Worktree Spaces"),
|
|
"issue-137-worktree-spaces"
|
|
);
|
|
assert_eq!(branch_to_path_slug("///"), "worktree");
|
|
}
|
|
|
|
#[test]
|
|
fn expand_tilde_path_uses_home_when_available() {
|
|
let old_home = std::env::var_os("HOME");
|
|
std::env::set_var("HOME", "/home/me");
|
|
assert_eq!(
|
|
expand_tilde_path("~/.herdr/worktrees"),
|
|
PathBuf::from("/home/me/.herdr/worktrees")
|
|
);
|
|
assert_eq!(
|
|
expand_tilde_path("/tmp/worktrees"),
|
|
PathBuf::from("/tmp/worktrees")
|
|
);
|
|
if let Some(home) = old_home {
|
|
std::env::set_var("HOME", home);
|
|
} else {
|
|
std::env::remove_var("HOME");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn default_checkout_path_appends_repo_and_branch_slug() {
|
|
assert_eq!(
|
|
default_checkout_path(
|
|
Path::new("/home/me/.herdr/worktrees"),
|
|
"herdr",
|
|
"worktree/brave-river",
|
|
),
|
|
PathBuf::from("/home/me/.herdr/worktrees/herdr/worktree-brave-river")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn worktree_remove_command_preserves_branch_by_not_deleting_it() {
|
|
let command = build_worktree_remove_command(
|
|
Path::new("/repo/herdr"),
|
|
Path::new("/w/herdr/issue-137"),
|
|
false,
|
|
);
|
|
assert_eq!(command.program, "git");
|
|
assert_eq!(
|
|
command.args,
|
|
vec![
|
|
"-C",
|
|
"/repo/herdr",
|
|
"worktree",
|
|
"remove",
|
|
"/w/herdr/issue-137"
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn forced_worktree_remove_command_uses_git_force_flag() {
|
|
let command = build_worktree_remove_command(
|
|
Path::new("/repo/herdr"),
|
|
Path::new("/w/herdr/issue-137"),
|
|
true,
|
|
);
|
|
assert_eq!(
|
|
command.args,
|
|
vec![
|
|
"-C",
|
|
"/repo/herdr",
|
|
"worktree",
|
|
"remove",
|
|
"--force",
|
|
"/w/herdr/issue-137"
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn dirty_remove_error_detection_matches_git_force_hint() {
|
|
assert!(is_dirty_worktree_remove_error(
|
|
"fatal: '/w/herdr' contains modified or untracked files, use --force to delete it"
|
|
));
|
|
assert!(!is_dirty_worktree_remove_error(
|
|
"fatal: '/w/herdr' is a missing but already registered worktree"
|
|
));
|
|
assert!(!is_dirty_worktree_remove_error(
|
|
"fatal: '/w/herdr' contains a locked worktree, use --force only if you know why"
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn worktree_add_command_creates_new_branch_from_base() {
|
|
let command = build_worktree_add_new_branch_command(
|
|
Path::new("/repo/herdr"),
|
|
Path::new("/w/herdr/worktree-brave-river"),
|
|
"worktree/brave-river",
|
|
"HEAD",
|
|
);
|
|
assert_eq!(command.program, "git");
|
|
assert_eq!(
|
|
command.args,
|
|
vec![
|
|
"-C",
|
|
"/repo/herdr",
|
|
"worktree",
|
|
"add",
|
|
"-b",
|
|
"worktree/brave-river",
|
|
"/w/herdr/worktree-brave-river",
|
|
"HEAD"
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn run_worktree_add_and_remove_create_and_delete_checkout() {
|
|
let repo = create_committed_repo("worktree-run-repo");
|
|
let checkout = unique_temp_path("worktree-run-checkout");
|
|
let branch = "worktree/test-create-remove";
|
|
|
|
let add = build_worktree_add_new_branch_command(&repo, &checkout, branch, "HEAD");
|
|
run_worktree_command(&add).unwrap();
|
|
|
|
assert!(checkout.join("README.md").exists());
|
|
let branch_name = std::process::Command::new("git")
|
|
.arg("-C")
|
|
.arg(&checkout)
|
|
.args(["branch", "--show-current"])
|
|
.output()
|
|
.unwrap();
|
|
assert!(branch_name.status.success());
|
|
assert_eq!(
|
|
String::from_utf8(branch_name.stdout).unwrap().trim(),
|
|
branch
|
|
);
|
|
|
|
let remove = build_worktree_remove_command(&repo, &checkout, false);
|
|
run_worktree_command(&remove).unwrap();
|
|
assert!(!checkout.exists());
|
|
|
|
let _ = std::fs::remove_dir_all(repo);
|
|
}
|
|
}
|