diff --git a/CLAUDE.md b/CLAUDE.md index ecae39c..d180043 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -37,17 +37,19 @@ Rust 1.100 (edition 2024), pinned in `mise.toml` and `rust-version` in `Cargo.to ## Architecture -gitrat is a terminal UI (TUI) for staging, viewing diffs, and committing — a lightweight alternative to `git add -p`. It has no library crates, only a single binary. +gitrat is a terminal UI (TUI) for staging, viewing diffs, and committing — a lightweight alternative to `git add -p`. `src/lib.rs` exposes every module as a library so integration tests can use it; `src/main.rs` is the binary (CLI + event loop). + +**Tests** live in `tests/` (one file per module: `git.rs`, `diff.rs`, `ui.rs`, `app.rs`, `theme.rs`), not in inline `#[cfg(test)]` modules. `tests/common/mod.rs` has `TempRepo`, which creates throwaway git repositories. Anything a test needs must be `pub`. **Data flow:** -1. `git.rs` — `Repo` (found via `git rev-parse --show-toplevel`) runs every git command from the repo root with stdin closed, `GIT_TERMINAL_PROMPT=0` and `GIT_OPTIONAL_LOCKS=0`. Parses `git status --porcelain=v1 -z --branch` into `Status { branch, files }`, builds diffs (`--no-color --no-ext-diff`, capped at 20k lines, control chars sanitized), and exposes stage/unstage/revert/remove/commit/push returning `GitResult<_>` (`Result<_, String>` with a readable message). Has integration tests that create temporary repositories. +1. `git.rs` — `Repo` (found via `git rev-parse --show-toplevel`) runs every git command from the repo root with stdin closed, `GIT_TERMINAL_PROMPT=0` and `GIT_OPTIONAL_LOCKS=0`. Parses `git status --porcelain=v1 -z --branch` into `Status { branch, files }`, builds diffs (`--no-color --no-ext-diff`, capped at 20k lines, control chars sanitized), and exposes stage/unstage/revert/remove/commit/push returning `GitResult<_>` (`Result<_, String>` with a readable message). 2. `types.rs` — plain data types: `FileEntry` (path, optional rename origin, raw `XY` status chars, `FileStatus`). 2b. `diff.rs` — turns raw `DiffSection`s into a `DiffView` of `Row`s (`RowKind`, old/new line numbers, styled `Seg`s). Hides git headers (keeps notes like "new file"/"renamed from"), syntax-highlights with syntect + two-face (bat's syntaxes), and marks changed words via a token-level LCS between paired removed/added lines. Caps: 20k rows, highlighting off above 8k rows or 1k-byte lines. 2c. `theme.rs` — `Theme` palette (diff backgrounds, accents, syntax theme OneHalfDark/GitHub). `--theme auto` uses `COLORFGBG`, then the OS setting (macOS `AppleInterfaceStyle`, Windows `AppsUseLightTheme`, GNOME `color-scheme`). Truecolor if `COLORTERM`/`WT_SESSION`/`TERM_PROGRAM` says so, else hand-picked xterm-256 fallbacks. 3. `app.rs` — `App` owns UI state: files, selection (kept by path across refreshes), `DiffView` + scroll (rebuilt only when the raw diff changes), `Mode` (`Normal`, `Input`, `Confirm`, `Help`), commit input, transient `Message`. `tick()` collects background push results, expires messages and auto-refreshes every 3 s. 4. `ui.rs` — render function; reads `App` (and records panel rects for mouse hit-testing). 30/70 side-by-side layout, stacked below 80 columns. Diff rows: `old new ± code` gutter, full-width tinted backgrounds, hunk header bars. Syntax tokens using the theme's default foreground render as `Color::Reset` so text stays readable if light/dark detection is wrong. 5. `terminal.rs` — raw mode, alternate screen, bracketed paste, focus events, optional mouse capture, and a panic hook that restores the terminal. -6. `main.rs` — clap CLI (`[PATH]`, `--no-mouse`, `--theme`), repo discovery before entering the TUI, poll-based event loop (250 ms tick). +6. `main.rs` — binary entry point using the `gitrat` lib: clap CLI (`[PATH]`, `--no-mouse`, `--theme`), repo discovery before entering the TUI, poll-based event loop (250 ms tick). 7. `event_handler.rs` — key/mouse/paste dispatch per `Mode`. **Key behaviors:** diff --git a/src/app.rs b/src/app.rs index 51a5120..2957a51 100644 --- a/src/app.rs +++ b/src/app.rs @@ -511,27 +511,9 @@ impl App { } /// Removes the last whitespace-separated word (and trailing spaces) from `text`. -fn delete_last_word(text: &mut String) { +pub fn delete_last_word(text: &mut String) { let trimmed = text.trim_end_matches(' ').len(); text.truncate(trimmed); let cut = text.rfind(' ').map_or(0, |i| i + 1); text.truncate(cut); } - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn deletes_last_word() { - let mut text = "fix: ação rápida ".to_string(); - delete_last_word(&mut text); - assert_eq!(text, "fix: ação "); - delete_last_word(&mut text); - assert_eq!(text, "fix: "); - delete_last_word(&mut text); - assert_eq!(text, ""); - delete_last_word(&mut text); - assert_eq!(text, ""); - } -} diff --git a/src/diff.rs b/src/diff.rs index 94141fc..0955998 100644 --- a/src/diff.rs +++ b/src/diff.rs @@ -490,11 +490,11 @@ fn tokens(text: &str) -> Vec> { } /// Byte ranges inside a line. -type Ranges = Vec>; +pub type Ranges = Vec>; /// Byte ranges that differ between `old` and `new`, from a token-level longest /// common subsequence, or `None` if the lines are too different to be worth it. -fn changed_ranges(old: &str, new: &str) -> Option<(Ranges, Ranges)> { +pub fn changed_ranges(old: &str, new: &str) -> Option<(Ranges, Ranges)> { let ot = tokens(old); let nt = tokens(new); if ot.len() > MAX_WORD_DIFF_TOKENS || nt.len() > MAX_WORD_DIFF_TOKENS { @@ -638,137 +638,3 @@ fn split_emphasis(pieces: &[(Style, &str)], emph: &[Range]) -> Vec { segs } - -#[cfg(test)] -mod tests { - use super::*; - - fn section(text: &str) -> Vec { - vec![DiffSection { - title: None, - text: text.to_string(), - }] - } - - fn plain(row: &Row) -> String { - row.segs.iter().map(|s| s.text.as_str()).collect() - } - - #[test] - fn parses_rows_and_line_numbers() { - let text = "diff --git a/x.txt b/x.txt\nindex 1..2 100644\n--- a/x.txt\n+++ b/x.txt\n@@ -10,3 +10,3 @@ fn main() {\n ctx\n-old\n+new\n ctx2\n\\ No newline at end of file\n"; - let view = build(§ion(text), "x.txt", &Theme::new(true, true)); - - let kinds: Vec = view.rows.iter().map(|r| r.kind).collect(); - assert_eq!( - kinds, - vec![ - RowKind::Hunk, - RowKind::Context, - RowKind::Removed, - RowKind::Added, - RowKind::Context, - RowKind::Info, - ] - ); - assert_eq!(view.rows[0].segs[0].text, "lines 10–12"); - assert_eq!(view.rows[0].segs[1].text, "fn main() {"); - assert_eq!((view.rows[1].old, view.rows[1].new), (Some(10), Some(10))); - assert_eq!((view.rows[2].old, view.rows[2].new), (Some(11), None)); - assert_eq!((view.rows[3].old, view.rows[3].new), (None, Some(11))); - assert_eq!((view.rows[4].old, view.rows[4].new), (Some(12), Some(12))); - assert_eq!((view.added, view.removed, view.max_line_no), (1, 1, 12)); - } - - #[test] - fn content_that_looks_like_headers_stays_code() { - let text = "diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n--- x\n+++ y\n"; - let view = build(§ion(text), "x", &Theme::new(true, true)); - assert_eq!(view.rows[1].kind, RowKind::Removed); - assert_eq!(plain(&view.rows[1]), "-- x"); - assert_eq!(view.rows[2].kind, RowKind::Added); - } - - #[test] - fn header_notes() { - let text = "diff --git a/n b/n\nnew file mode 100644\nindex 0..1\nBinary files /dev/null and b/n differ\n"; - let view = build(§ion(text), "n", &Theme::new(true, true)); - let notes: Vec = view.rows.iter().map(plain).collect(); - assert_eq!(notes, vec!["new file", "binary file changed"]); - } - - fn changed_words(old: &str, new: &str) -> Option<(Vec, Vec)> { - changed_ranges(old, new).map(|(o, n)| { - ( - o.into_iter().map(|r| old[r].to_string()).collect(), - n.into_iter().map(|r| new[r].to_string()).collect(), - ) - }) - } - - #[test] - fn word_level_emphasis() { - assert_eq!( - changed_words( - "#[derive(Debug, Clone, PartialEq)]", - "#[derive(Debug, Clone, Copy, PartialEq, Eq)]", - ), - Some((vec![], vec!["Copy, ".into(), ", Eq".into()])) - ); - assert_eq!( - changed_words( - "/// File has been deleted from the working tree.", - "/// File has been deleted from the working tree (not staged).", - ), - Some((vec![], vec![" (not staged)".into()])) - ); - - assert!(changed_words("completely different", "nothing alike here!").is_none()); - assert!(changed_words("same", "same").is_none()); - } - - #[test] - fn highlights_rust_and_marks_emphasis() { - let text = "@@ -1 +1 @@\n-let x = 1;\n+let x = 2;\n"; - let view = build(§ion(text), "src/main.rs", &Theme::new(true, true)); - let added = &view.rows[2]; - assert!(added.segs.len() > 1, "expected syntax colours: {added:?}"); - let emph: String = added - .segs - .iter() - .filter(|s| s.emph) - .map(|s| s.text.as_str()) - .collect(); - assert_eq!(emph, "2"); - assert_eq!(plain(added), "let x = 2;"); - } - - #[test] - fn sections_and_empty_sections() { - let sections = vec![ - DiffSection { - title: Some("Staged changes".into()), - text: "@@ -1 +1 @@\n-a\n+b\n".into(), - }, - DiffSection { - title: Some("Unstaged changes".into()), - text: String::new(), - }, - ]; - let view = build(§ions, "f", &Theme::new(false, false)); - let kinds: Vec = view.rows.iter().map(|r| r.kind).collect(); - assert_eq!(kinds[0], RowKind::Section); - assert!(kinds.contains(&RowKind::Info)); - assert_eq!(kinds.iter().filter(|k| **k == RowKind::Section).count(), 2); - } - - #[test] - fn combined_conflict_diff() { - let text = "diff --cc f\n@@@ -1,1 -1,1 +1,5 @@@\n++<<<<<<< ours\n +a\n++=======\n+ b\n++>>>>>>> theirs\n"; - let view = build(§ion(text), "f", &Theme::new(true, false)); - assert_eq!(view.rows[0].kind, RowKind::Hunk); - assert_eq!(plain(&view.rows[1]), "<<<<<<< ours"); - assert!(view.rows[1..].iter().all(|r| r.kind == RowKind::Added)); - assert_eq!(view.rows[5].new, Some(5)); - } -} diff --git a/src/git.rs b/src/git.rs index d4722d1..b56cea3 100644 --- a/src/git.rs +++ b/src/git.rs @@ -64,6 +64,11 @@ impl Repo { }) } + /// Absolute path of the repository's work tree root. + pub fn root(&self) -> &Path { + &self.root + } + fn command(&self, args: I) -> Command where I: IntoIterator, @@ -481,273 +486,3 @@ fn error_message(out: &Output) -> String { } } } - -#[cfg(test)] -pub(crate) mod tests { - use std::fs; - use std::sync::atomic::AtomicUsize; - use std::sync::atomic::Ordering; - - use super::*; - - #[test] - fn parses_status_records() { - let text = "## main...origin/main [ahead 1]\0 M src/a.rs\0M b.rs\0MM c d.rs\0?? new\tfile\0 D gone.rs\0R new.rs\0old.rs\0UU conflict.rs\0A added.rs\0"; - let status = parse_status(text); - - assert_eq!(status.branch, "main...origin/main [ahead 1]"); - let got: Vec<(&str, FileStatus)> = status - .files - .iter() - .map(|f| (f.path.as_str(), f.status)) - .collect(); - assert_eq!( - got, - vec![ - ("src/a.rs", FileStatus::Modified), - ("b.rs", FileStatus::Staged), - ("c d.rs", FileStatus::StagedModified), - ("new\tfile", FileStatus::Untracked), - ("gone.rs", FileStatus::Deleted), - ("new.rs", FileStatus::Staged), - ("conflict.rs", FileStatus::Conflicted), - ("added.rs", FileStatus::Staged), - ] - ); - assert_eq!(status.files[5].orig_path.as_deref(), Some("old.rs")); - } - - #[test] - fn sanitizes_control_characters() { - assert_eq!(sanitize("a\tb\x1b[31mc\r"), "a b\u{FFFD}[31mc"); - } - - pub(crate) struct TempRepo { - pub(crate) dir: PathBuf, - pub(crate) repo: Repo, - } - - impl TempRepo { - pub(crate) fn new() -> Self { - static COUNTER: AtomicUsize = AtomicUsize::new(0); - let dir = std::env::temp_dir().join(format!( - "gitrat-test-{}-{}", - std::process::id(), - COUNTER.fetch_add(1, Ordering::SeqCst) - )); - let _ = fs::remove_dir_all(&dir); - fs::create_dir_all(&dir).unwrap(); - - let git = |args: &[&str]| { - let ok = Command::new("git") - .current_dir(&dir) - .args(args) - .output() - .unwrap() - .status - .success(); - assert!(ok, "git {args:?} failed"); - }; - - git(&["init", "--quiet", "--initial-branch=main"]); - git(&["config", "user.name", "gitrat test"]); - git(&["config", "user.email", "test@example.com"]); - git(&["config", "commit.gpgsign", "false"]); - git(&["config", "core.hooksPath", "/dev/null"]); - // Git for Windows defaults to CRLF conversion, which would change diffs. - git(&["config", "core.autocrlf", "false"]); - - let repo = Repo::discover(&dir).unwrap(); - Self { dir, repo } - } - - pub(crate) fn write(&self, path: &str, content: &str) { - let path = self.dir.join(path); - fs::create_dir_all(path.parent().unwrap()).unwrap(); - fs::write(path, content).unwrap(); - } - - fn file(&self, path: &str) -> FileEntry { - self - .repo - .status() - .unwrap() - .files - .into_iter() - .find(|f| f.path == path) - .unwrap_or_else(|| panic!("{path} not in status")) - } - } - - impl Drop for TempRepo { - fn drop(&mut self) { - let _ = fs::remove_dir_all(&self.dir); - } - } - - #[test] - fn discover_from_subdirectory_uses_root() { - let t = TempRepo::new(); - t.write("sub/dir/f.txt", "x"); - let repo = Repo::discover(&t.dir.join("sub/dir")).unwrap(); - assert_eq!( - repo.root.canonicalize().unwrap(), - t.dir.canonicalize().unwrap() - ); - assert_eq!(repo.status().unwrap().files[0].path, "sub/dir/f.txt"); - } - - #[test] - fn discover_outside_repo_fails() { - assert!(Repo::discover(Path::new("/")).is_err()); - } - - #[test] - fn stage_unstage_and_commit_without_head() { - let t = TempRepo::new(); - t.write("a.txt", "hello\n"); - - let f = t.file("a.txt"); - assert_eq!(f.status, FileStatus::Untracked); - assert!(t.repo.diff(&f).unwrap()[0].text.contains("+hello")); - - t.repo.toggle_stage(&f).unwrap(); - let f = t.file("a.txt"); - assert_eq!(f.status, FileStatus::Staged); - - // Unstaging must work in a repository with no commits yet. - t.repo.toggle_stage(&f).unwrap(); - assert_eq!(t.file("a.txt").status, FileStatus::Untracked); - - assert!(t.repo.commit("empty").is_err()); - t.repo.stage_all().unwrap(); - let msg = t.repo.commit(" first commit ").unwrap(); - assert!(msg.contains("first commit"), "{msg}"); - assert!(t.repo.status().unwrap().files.is_empty()); - } - - #[test] - fn revert_and_remove() { - let t = TempRepo::new(); - t.write("a.txt", "one\n"); - t.write("-dash.txt", "one\n"); - t.repo.stage_all().unwrap(); - t.repo.commit("init").unwrap(); - - t.write("a.txt", "two\n"); - t.repo.stage(&t.file("a.txt")).unwrap(); - t.write("a.txt", "three\n"); - let f = t.file("a.txt"); - assert_eq!(f.status, FileStatus::StagedModified); - let diff = t.repo.diff(&f).unwrap(); - assert_eq!(diff.len(), 2); - assert!(diff[0].text.contains("+two") && diff[1].text.contains("+three")); - t.repo.revert(&f).unwrap(); - assert_eq!(fs::read_to_string(t.dir.join("a.txt")).unwrap(), "one\n"); - - // Paths beginning with '-' must not be parsed as options. - t.write("-dash.txt", "two\n"); - t.repo.revert(&t.file("-dash.txt")).unwrap(); - assert!(t.repo.status().unwrap().files.is_empty()); - - t.write("junk.txt", "x"); - let junk = t.file("junk.txt"); - assert!(t.repo.revert(&junk).is_err()); - t.repo.remove(&junk).unwrap(); - assert!(!t.dir.join("junk.txt").exists()); - - t.repo.remove(&t.file_tracked("a.txt")).unwrap(); - assert_eq!(t.file("a.txt").status, FileStatus::Staged); - } - - #[test] - fn revert_new_file_only_unstages() { - let t = TempRepo::new(); - t.write("base", "x"); - t.repo.stage_all().unwrap(); - t.repo.commit("init").unwrap(); - - t.write("new.txt", "keep me"); - t.repo.stage(&t.file("new.txt")).unwrap(); - t.repo.revert(&t.file("new.txt")).unwrap(); - assert_eq!(t.file("new.txt").status, FileStatus::Untracked); - assert!(t.dir.join("new.txt").exists()); - } - - #[test] - fn rename_unstage_and_revert() { - let t = TempRepo::new(); - t.write("old.txt", "content\n"); - t.repo.stage_all().unwrap(); - t.repo.commit("init").unwrap(); - - fs::rename(t.dir.join("old.txt"), t.dir.join("new.txt")).unwrap(); - t.repo.stage_all().unwrap(); - let f = t.file("new.txt"); - assert_eq!(f.index, 'R'); - assert_eq!(f.orig_path.as_deref(), Some("old.txt")); - assert!( - t.repo.diff(&f).unwrap()[0] - .text - .contains("rename from old.txt") - ); - - t.repo.revert(&f).unwrap(); - assert!(t.dir.join("old.txt").exists()); - assert_eq!(t.file("new.txt").status, FileStatus::Untracked); - } - - #[test] - fn push_sets_upstream_then_pushes() { - let t = TempRepo::new(); - // No commits and no remote yet. - assert!(t.repo.push().is_err()); - - let remote = t.dir.with_extension("remote.git"); - let _ = fs::remove_dir_all(&remote); - assert!( - Command::new("git") - .args(["init", "--quiet", "--bare"]) - .arg(&remote) - .status() - .unwrap() - .success() - ); - - t.write("a", "1"); - t.repo.stage_all().unwrap(); - t.repo.commit("one").unwrap(); - assert!(t.repo.push().unwrap_err().contains("no remote")); - - t.repo - .run(["remote", "add", "origin", remote.to_str().unwrap()]) - .unwrap(); - assert_eq!(t.repo.push().unwrap(), "pushed main and set upstream"); - - t.write("a", "2"); - t.repo.stage_all().unwrap(); - t.repo.commit("two").unwrap(); - assert_eq!(t.repo.push().unwrap(), "pushed main"); - assert!( - t.repo - .status() - .unwrap() - .branch - .starts_with("main...origin/main") - ); - - let _ = fs::remove_dir_all(&remote); - } - - impl TempRepo { - fn file_tracked(&self, path: &str) -> FileEntry { - FileEntry { - path: path.to_string(), - orig_path: None, - index: ' ', - worktree: ' ', - status: FileStatus::Modified, - } - } - } -} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..ffce917 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,13 @@ +//! gitrat: a terminal UI for staging, viewing diffs and committing. +//! +//! The binary (`main.rs`) only parses the CLI and runs the event loop; every +//! module lives here so the integration tests in `tests/` can use it. + +pub mod app; +pub mod diff; +pub mod event_handler; +pub mod git; +pub mod terminal; +pub mod theme; +pub mod types; +pub mod ui; diff --git a/src/main.rs b/src/main.rs index 3b4b99e..a5b63c7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,22 +1,18 @@ -mod app; -mod diff; -mod event_handler; -mod git; -mod terminal; -mod theme; -mod types; -mod ui; - use std::io; use std::io::IsTerminal; use std::path::PathBuf; use std::process::ExitCode; use std::time::Duration; -use app::App; use clap::Parser; use crossterm::event; use crossterm::event::Event; +use gitrat::app::App; +use gitrat::event_handler; +use gitrat::git; +use gitrat::terminal; +use gitrat::theme; +use gitrat::ui; /// How long to wait for input before running background work (push results, /// auto-refresh, message expiry). diff --git a/src/theme.rs b/src/theme.rs index 94edc89..100347c 100644 --- a/src/theme.rs +++ b/src/theme.rs @@ -196,7 +196,7 @@ fn command_stdout(program: &str, args: &[&str]) -> Option { } /// Nearest xterm-256 colour (6×6×6 cube or grey ramp). -fn rgb_to_256(r: u8, g: u8, b: u8) -> u8 { +pub fn rgb_to_256(r: u8, g: u8, b: u8) -> u8 { const LEVELS: [u8; 6] = [0, 95, 135, 175, 215, 255]; let level = |v: u8| -> usize { match v { @@ -228,27 +228,3 @@ fn rgb_to_256(r: u8, g: u8, b: u8) -> u8 { 16 + (36 * ri + 6 * gi + bi) as u8 } } - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn converts_to_256() { - assert_eq!(rgb_to_256(0, 0, 0), 16); - assert_eq!(rgb_to_256(255, 255, 255), 231); - assert_eq!(rgb_to_256(255, 0, 0), 196); - assert_eq!(rgb_to_256(128, 128, 128), 244); - } - - #[test] - fn builds_both_variants() { - for dark in [true, false] { - for truecolor in [true, false] { - let theme = Theme::new(dark, truecolor); - assert_eq!(theme.truecolor, truecolor); - assert!(theme.syntax.settings.foreground.is_some()); - } - } - } -} diff --git a/src/ui.rs b/src/ui.rs index 1ec56ed..3d6bdc1 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -532,7 +532,7 @@ fn render_help(frame: &mut Frame, area: Rect, accent: Color) { } /// Truncates `text` from the left with `…` so the end (the file name) stays visible. -fn truncate_left(text: &str, max: usize) -> String { +pub fn truncate_left(text: &str, max: usize) -> String { if text.width() <= max { return text.to_string(); } @@ -557,7 +557,7 @@ fn truncate_left(text: &str, max: usize) -> String { } /// Truncates `text` from the right with `…`. -fn truncate_right(text: &str, max: usize) -> String { +pub fn truncate_right(text: &str, max: usize) -> String { if text.width() <= max { return text.to_string(); } @@ -580,7 +580,7 @@ fn truncate_right(text: &str, max: usize) -> String { /// Returns the longest suffix of `text` that fits in `max` columns (so the /// commit input scrolls horizontally while typing long messages). -fn tail_fitting(text: &str, max: usize) -> &str { +pub fn tail_fitting(text: &str, max: usize) -> &str { let mut width = 0; let mut start = text.len(); for (i, c) in text.char_indices().rev() { @@ -597,7 +597,7 @@ fn tail_fitting(text: &str, max: usize) -> &str { } /// Drops the first `cols` display columns of `text` (horizontal diff scroll). -fn skip_columns(text: &str, cols: usize) -> String { +pub fn skip_columns(text: &str, cols: usize) -> String { if cols == 0 { return text.to_string(); } @@ -620,41 +620,3 @@ fn skip_columns(text: &str, cols: usize) -> String { out } - -#[cfg(test)] -mod tests { - use ratatui::Terminal; - use ratatui::backend::TestBackend; - - use super::*; - - #[test] - fn truncation_helpers() { - assert_eq!(truncate_left("src/very/long/path.rs", 10), "…g/path.rs"); - assert_eq!(truncate_left("short", 10), "short"); - assert_eq!(truncate_right("hello world", 6), "hello…"); - assert_eq!(tail_fitting("ação rápida", 6), "rápida"); - assert_eq!(tail_fitting("日本語", 4), "本語"); - assert_eq!(skip_columns("abcdef", 2), "cdef"); - assert_eq!(skip_columns("日本語", 1), " 本語"); - } - - #[test] - fn renders_in_small_and_large_terminals() { - let t = crate::git::tests::TempRepo::new(); - t.write("dir/a file with a very long name.txt", "x\ty\u{1b}[2J\n"); - let mut app = App::new(t.repo.clone(), Theme::new(true, false)); - for (w, h) in [(10, 5), (40, 12), (79, 24), (200, 60)] { - let mut terminal = Terminal::new(TestBackend::new(w, h)).unwrap(); - for mode in [ - Mode::Normal, - Mode::Input, - Mode::Help, - Mode::Confirm(Confirm::Revert), - ] { - app.mode = mode; - terminal.draw(|f| render(f, &mut app)).unwrap(); - } - } - } -} diff --git a/tests/app.rs b/tests/app.rs new file mode 100644 index 0000000..3449465 --- /dev/null +++ b/tests/app.rs @@ -0,0 +1,14 @@ +use gitrat::app::delete_last_word; + +#[test] +fn deletes_last_word() { + let mut text = "fix: ação rápida ".to_string(); + delete_last_word(&mut text); + assert_eq!(text, "fix: ação "); + delete_last_word(&mut text); + assert_eq!(text, "fix: "); + delete_last_word(&mut text); + assert_eq!(text, ""); + delete_last_word(&mut text); + assert_eq!(text, ""); +} diff --git a/tests/common/mod.rs b/tests/common/mod.rs new file mode 100644 index 0000000..f067e22 --- /dev/null +++ b/tests/common/mod.rs @@ -0,0 +1,95 @@ +//! Shared helpers for integration tests: throwaway git repositories. + +#![allow(dead_code)] + +use std::fs; +use std::path::Path; +use std::path::PathBuf; +use std::process::Command; +use std::sync::atomic::AtomicUsize; +use std::sync::atomic::Ordering; + +use gitrat::git::Repo; +use gitrat::types::FileEntry; +use gitrat::types::FileStatus; + +/// A git repository in a temporary directory, deleted on drop. +pub struct TempRepo { + pub dir: PathBuf, + pub repo: Repo, +} + +impl TempRepo { + pub fn new() -> Self { + static COUNTER: AtomicUsize = AtomicUsize::new(0); + let dir = std::env::temp_dir().join(format!( + "gitrat-test-{}-{}", + std::process::id(), + COUNTER.fetch_add(1, Ordering::SeqCst) + )); + let _ = fs::remove_dir_all(&dir); + fs::create_dir_all(&dir).unwrap(); + + git_in(&dir, &["init", "--quiet", "--initial-branch=main"]); + git_in(&dir, &["config", "user.name", "gitrat test"]); + git_in(&dir, &["config", "user.email", "test@example.com"]); + git_in(&dir, &["config", "commit.gpgsign", "false"]); + git_in(&dir, &["config", "core.hooksPath", "/dev/null"]); + // Git for Windows defaults to CRLF conversion, which would change diffs. + git_in(&dir, &["config", "core.autocrlf", "false"]); + + let repo = Repo::discover(&dir).unwrap(); + Self { dir, repo } + } + + /// Runs git inside the repository and asserts that it succeeded. + pub fn git(&self, args: &[&str]) { + git_in(&self.dir, args); + } + + pub fn write(&self, path: &str, content: &str) { + let path = self.dir.join(path); + fs::create_dir_all(path.parent().unwrap()).unwrap(); + fs::write(path, content).unwrap(); + } + + /// The status entry for `path`; panics if it is not changed. + pub fn file(&self, path: &str) -> FileEntry { + self + .repo + .status() + .unwrap() + .files + .into_iter() + .find(|f| f.path == path) + .unwrap_or_else(|| panic!("{path} not in status")) + } + + /// A synthetic entry for a tracked, unmodified file. + pub fn file_tracked(&self, path: &str) -> FileEntry { + FileEntry { + path: path.to_string(), + orig_path: None, + index: ' ', + worktree: ' ', + status: FileStatus::Modified, + } + } +} + +impl Drop for TempRepo { + fn drop(&mut self) { + let _ = fs::remove_dir_all(&self.dir); + } +} + +fn git_in(dir: &Path, args: &[&str]) { + let ok = Command::new("git") + .current_dir(dir) + .args(args) + .output() + .unwrap() + .status + .success(); + assert!(ok, "git {args:?} failed"); +} diff --git a/tests/diff.rs b/tests/diff.rs new file mode 100644 index 0000000..3d8443f --- /dev/null +++ b/tests/diff.rs @@ -0,0 +1,137 @@ +use gitrat::diff::Row; +use gitrat::diff::RowKind; +use gitrat::diff::build; +use gitrat::diff::changed_ranges; +use gitrat::git::DiffSection; +use gitrat::theme::Theme; + +fn section(text: &str) -> Vec { + vec![DiffSection { + title: None, + text: text.to_string(), + }] +} + +fn plain(row: &Row) -> String { + row.segs.iter().map(|s| s.text.as_str()).collect() +} + +#[test] +fn parses_rows_and_line_numbers() { + let text = "diff --git a/x.txt b/x.txt\nindex 1..2 100644\n--- a/x.txt\n+++ b/x.txt\n@@ -10,3 +10,3 @@ fn main() {\n ctx\n-old\n+new\n ctx2\n\\ No newline at end of file\n"; + let view = build(§ion(text), "x.txt", &Theme::new(true, true)); + + let kinds: Vec = view.rows.iter().map(|r| r.kind).collect(); + assert_eq!( + kinds, + vec![ + RowKind::Hunk, + RowKind::Context, + RowKind::Removed, + RowKind::Added, + RowKind::Context, + RowKind::Info, + ] + ); + assert_eq!(view.rows[0].segs[0].text, "lines 10–12"); + assert_eq!(view.rows[0].segs[1].text, "fn main() {"); + assert_eq!((view.rows[1].old, view.rows[1].new), (Some(10), Some(10))); + assert_eq!((view.rows[2].old, view.rows[2].new), (Some(11), None)); + assert_eq!((view.rows[3].old, view.rows[3].new), (None, Some(11))); + assert_eq!((view.rows[4].old, view.rows[4].new), (Some(12), Some(12))); + assert_eq!((view.added, view.removed, view.max_line_no), (1, 1, 12)); +} + +#[test] +fn content_that_looks_like_headers_stays_code() { + let text = "diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n--- x\n+++ y\n"; + let view = build(§ion(text), "x", &Theme::new(true, true)); + assert_eq!(view.rows[1].kind, RowKind::Removed); + assert_eq!(plain(&view.rows[1]), "-- x"); + assert_eq!(view.rows[2].kind, RowKind::Added); +} + +#[test] +fn header_notes() { + let text = + "diff --git a/n b/n\nnew file mode 100644\nindex 0..1\nBinary files /dev/null and b/n differ\n"; + let view = build(§ion(text), "n", &Theme::new(true, true)); + let notes: Vec = view.rows.iter().map(plain).collect(); + assert_eq!(notes, vec!["new file", "binary file changed"]); +} + +fn changed_words(old: &str, new: &str) -> Option<(Vec, Vec)> { + changed_ranges(old, new).map(|(o, n)| { + ( + o.into_iter().map(|r| old[r].to_string()).collect(), + n.into_iter().map(|r| new[r].to_string()).collect(), + ) + }) +} + +#[test] +fn word_level_emphasis() { + assert_eq!( + changed_words( + "#[derive(Debug, Clone, PartialEq)]", + "#[derive(Debug, Clone, Copy, PartialEq, Eq)]", + ), + Some((vec![], vec!["Copy, ".into(), ", Eq".into()])) + ); + assert_eq!( + changed_words( + "/// File has been deleted from the working tree.", + "/// File has been deleted from the working tree (not staged).", + ), + Some((vec![], vec![" (not staged)".into()])) + ); + + assert!(changed_words("completely different", "nothing alike here!").is_none()); + assert!(changed_words("same", "same").is_none()); +} + +#[test] +fn highlights_rust_and_marks_emphasis() { + let text = "@@ -1 +1 @@\n-let x = 1;\n+let x = 2;\n"; + let view = build(§ion(text), "src/main.rs", &Theme::new(true, true)); + let added = &view.rows[2]; + assert!(added.segs.len() > 1, "expected syntax colours: {added:?}"); + let emph: String = added + .segs + .iter() + .filter(|s| s.emph) + .map(|s| s.text.as_str()) + .collect(); + assert_eq!(emph, "2"); + assert_eq!(plain(added), "let x = 2;"); +} + +#[test] +fn sections_and_empty_sections() { + let sections = vec![ + DiffSection { + title: Some("Staged changes".into()), + text: "@@ -1 +1 @@\n-a\n+b\n".into(), + }, + DiffSection { + title: Some("Unstaged changes".into()), + text: String::new(), + }, + ]; + let view = build(§ions, "f", &Theme::new(false, false)); + let kinds: Vec = view.rows.iter().map(|r| r.kind).collect(); + assert_eq!(kinds[0], RowKind::Section); + assert!(kinds.contains(&RowKind::Info)); + assert_eq!(kinds.iter().filter(|k| **k == RowKind::Section).count(), 2); +} + +#[test] +fn combined_conflict_diff() { + let text = + "diff --cc f\n@@@ -1,1 -1,1 +1,5 @@@\n++<<<<<<< ours\n +a\n++=======\n+ b\n++>>>>>>> theirs\n"; + let view = build(§ion(text), "f", &Theme::new(true, false)); + assert_eq!(view.rows[0].kind, RowKind::Hunk); + assert_eq!(plain(&view.rows[1]), "<<<<<<< ours"); + assert!(view.rows[1..].iter().all(|r| r.kind == RowKind::Added)); + assert_eq!(view.rows[5].new, Some(5)); +} diff --git a/tests/git.rs b/tests/git.rs new file mode 100644 index 0000000..76d6922 --- /dev/null +++ b/tests/git.rs @@ -0,0 +1,195 @@ +mod common; + +use std::fs; +use std::path::Path; +use std::process::Command; + +use common::TempRepo; +use gitrat::git::Repo; +use gitrat::git::parse_status; +use gitrat::git::sanitize; +use gitrat::types::FileStatus; + +#[test] +fn parses_status_records() { + let text = "## main...origin/main [ahead 1]\0 M src/a.rs\0M b.rs\0MM c d.rs\0?? new\tfile\0 D gone.rs\0R new.rs\0old.rs\0UU conflict.rs\0A added.rs\0"; + let status = parse_status(text); + + assert_eq!(status.branch, "main...origin/main [ahead 1]"); + let got: Vec<(&str, FileStatus)> = status + .files + .iter() + .map(|f| (f.path.as_str(), f.status)) + .collect(); + assert_eq!( + got, + vec![ + ("src/a.rs", FileStatus::Modified), + ("b.rs", FileStatus::Staged), + ("c d.rs", FileStatus::StagedModified), + ("new\tfile", FileStatus::Untracked), + ("gone.rs", FileStatus::Deleted), + ("new.rs", FileStatus::Staged), + ("conflict.rs", FileStatus::Conflicted), + ("added.rs", FileStatus::Staged), + ] + ); + assert_eq!(status.files[5].orig_path.as_deref(), Some("old.rs")); +} + +#[test] +fn sanitizes_control_characters() { + assert_eq!(sanitize("a\tb\x1b[31mc\r"), "a b\u{FFFD}[31mc"); +} + +#[test] +fn discover_from_subdirectory_uses_root() { + let t = TempRepo::new(); + t.write("sub/dir/f.txt", "x"); + let repo = Repo::discover(&t.dir.join("sub/dir")).unwrap(); + assert_eq!( + repo.root().canonicalize().unwrap(), + t.dir.canonicalize().unwrap() + ); + assert_eq!(repo.status().unwrap().files[0].path, "sub/dir/f.txt"); +} + +#[test] +fn discover_outside_repo_fails() { + assert!(Repo::discover(Path::new("/")).is_err()); +} + +#[test] +fn stage_unstage_and_commit_without_head() { + let t = TempRepo::new(); + t.write("a.txt", "hello\n"); + + let f = t.file("a.txt"); + assert_eq!(f.status, FileStatus::Untracked); + assert!(t.repo.diff(&f).unwrap()[0].text.contains("+hello")); + + t.repo.toggle_stage(&f).unwrap(); + let f = t.file("a.txt"); + assert_eq!(f.status, FileStatus::Staged); + + // Unstaging must work in a repository with no commits yet. + t.repo.toggle_stage(&f).unwrap(); + assert_eq!(t.file("a.txt").status, FileStatus::Untracked); + + assert!(t.repo.commit("empty").is_err()); + t.repo.stage_all().unwrap(); + let msg = t.repo.commit(" first commit ").unwrap(); + assert!(msg.contains("first commit"), "{msg}"); + assert!(t.repo.status().unwrap().files.is_empty()); +} + +#[test] +fn revert_and_remove() { + let t = TempRepo::new(); + t.write("a.txt", "one\n"); + t.write("-dash.txt", "one\n"); + t.repo.stage_all().unwrap(); + t.repo.commit("init").unwrap(); + + t.write("a.txt", "two\n"); + t.repo.stage(&t.file("a.txt")).unwrap(); + t.write("a.txt", "three\n"); + let f = t.file("a.txt"); + assert_eq!(f.status, FileStatus::StagedModified); + let diff = t.repo.diff(&f).unwrap(); + assert_eq!(diff.len(), 2); + assert!(diff[0].text.contains("+two") && diff[1].text.contains("+three")); + t.repo.revert(&f).unwrap(); + assert_eq!(fs::read_to_string(t.dir.join("a.txt")).unwrap(), "one\n"); + + // Paths beginning with '-' must not be parsed as options. + t.write("-dash.txt", "two\n"); + t.repo.revert(&t.file("-dash.txt")).unwrap(); + assert!(t.repo.status().unwrap().files.is_empty()); + + t.write("junk.txt", "x"); + let junk = t.file("junk.txt"); + assert!(t.repo.revert(&junk).is_err()); + t.repo.remove(&junk).unwrap(); + assert!(!t.dir.join("junk.txt").exists()); + + t.repo.remove(&t.file_tracked("a.txt")).unwrap(); + assert_eq!(t.file("a.txt").status, FileStatus::Staged); +} + +#[test] +fn revert_new_file_only_unstages() { + let t = TempRepo::new(); + t.write("base", "x"); + t.repo.stage_all().unwrap(); + t.repo.commit("init").unwrap(); + + t.write("new.txt", "keep me"); + t.repo.stage(&t.file("new.txt")).unwrap(); + t.repo.revert(&t.file("new.txt")).unwrap(); + assert_eq!(t.file("new.txt").status, FileStatus::Untracked); + assert!(t.dir.join("new.txt").exists()); +} + +#[test] +fn rename_unstage_and_revert() { + let t = TempRepo::new(); + t.write("old.txt", "content\n"); + t.repo.stage_all().unwrap(); + t.repo.commit("init").unwrap(); + + fs::rename(t.dir.join("old.txt"), t.dir.join("new.txt")).unwrap(); + t.repo.stage_all().unwrap(); + let f = t.file("new.txt"); + assert_eq!(f.index, 'R'); + assert_eq!(f.orig_path.as_deref(), Some("old.txt")); + assert!( + t.repo.diff(&f).unwrap()[0] + .text + .contains("rename from old.txt") + ); + + t.repo.revert(&f).unwrap(); + assert!(t.dir.join("old.txt").exists()); + assert_eq!(t.file("new.txt").status, FileStatus::Untracked); +} + +#[test] +fn push_sets_upstream_then_pushes() { + let t = TempRepo::new(); + // No commits and no remote yet. + assert!(t.repo.push().is_err()); + + let remote = t.dir.with_extension("remote.git"); + let _ = fs::remove_dir_all(&remote); + assert!( + Command::new("git") + .args(["init", "--quiet", "--bare"]) + .arg(&remote) + .status() + .unwrap() + .success() + ); + + t.write("a", "1"); + t.repo.stage_all().unwrap(); + t.repo.commit("one").unwrap(); + assert!(t.repo.push().unwrap_err().contains("no remote")); + + t.git(&["remote", "add", "origin", remote.to_str().unwrap()]); + assert_eq!(t.repo.push().unwrap(), "pushed main and set upstream"); + + t.write("a", "2"); + t.repo.stage_all().unwrap(); + t.repo.commit("two").unwrap(); + assert_eq!(t.repo.push().unwrap(), "pushed main"); + assert!( + t.repo + .status() + .unwrap() + .branch + .starts_with("main...origin/main") + ); + + let _ = fs::remove_dir_all(&remote); +} diff --git a/tests/theme.rs b/tests/theme.rs new file mode 100644 index 0000000..64bb8b8 --- /dev/null +++ b/tests/theme.rs @@ -0,0 +1,21 @@ +use gitrat::theme::Theme; +use gitrat::theme::rgb_to_256; + +#[test] +fn converts_to_256() { + assert_eq!(rgb_to_256(0, 0, 0), 16); + assert_eq!(rgb_to_256(255, 255, 255), 231); + assert_eq!(rgb_to_256(255, 0, 0), 196); + assert_eq!(rgb_to_256(128, 128, 128), 244); +} + +#[test] +fn builds_both_variants() { + for dark in [true, false] { + for truecolor in [true, false] { + let theme = Theme::new(dark, truecolor); + assert_eq!(theme.truecolor, truecolor); + assert!(theme.syntax.settings.foreground.is_some()); + } + } +} diff --git a/tests/ui.rs b/tests/ui.rs new file mode 100644 index 0000000..9074234 --- /dev/null +++ b/tests/ui.rs @@ -0,0 +1,44 @@ +mod common; + +use common::TempRepo; +use gitrat::app::App; +use gitrat::app::Confirm; +use gitrat::app::Mode; +use gitrat::theme::Theme; +use gitrat::ui::render; +use gitrat::ui::skip_columns; +use gitrat::ui::tail_fitting; +use gitrat::ui::truncate_left; +use gitrat::ui::truncate_right; +use ratatui::Terminal; +use ratatui::backend::TestBackend; + +#[test] +fn truncation_helpers() { + assert_eq!(truncate_left("src/very/long/path.rs", 10), "…g/path.rs"); + assert_eq!(truncate_left("short", 10), "short"); + assert_eq!(truncate_right("hello world", 6), "hello…"); + assert_eq!(tail_fitting("ação rápida", 6), "rápida"); + assert_eq!(tail_fitting("日本語", 4), "本語"); + assert_eq!(skip_columns("abcdef", 2), "cdef"); + assert_eq!(skip_columns("日本語", 1), " 本語"); +} + +#[test] +fn renders_in_small_and_large_terminals() { + let t = TempRepo::new(); + t.write("dir/a file with a very long name.txt", "x\ty\u{1b}[2J\n"); + let mut app = App::new(t.repo.clone(), Theme::new(true, false)); + for (w, h) in [(10, 5), (40, 12), (79, 24), (200, 60)] { + let mut terminal = Terminal::new(TestBackend::new(w, h)).unwrap(); + for mode in [ + Mode::Normal, + Mode::Input, + Mode::Help, + Mode::Confirm(Confirm::Revert), + ] { + app.mode = mode; + terminal.draw(|f| render(f, &mut app)).unwrap(); + } + } +}