kabu 0.7.1

CLI tool to enhance git worktree and jj workspace with automated setup
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::config::OnConflict;
use crate::error::Result;

use std::path::Path;

/// Action to take after conflict resolution.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ConflictAction {
    Proceed,
    Skip,
    Abort,
}

/// Check if target path already exists.
pub(crate) fn check_conflict(target: &Path) -> bool {
    target.exists()
}

/// Resolve conflict by removing or backing up the target.
pub(crate) fn resolve_conflict(target: &Path, mode: OnConflict) -> Result<ConflictAction> {
    match mode {
        OnConflict::Abort => Ok(ConflictAction::Abort),
        OnConflict::Skip => Ok(ConflictAction::Skip),
        OnConflict::Overwrite => {
            // Remove existing file/symlink
            if target.is_symlink() || target.is_file() {
                std::fs::remove_file(target)?;
            } else if target.is_dir() {
                std::fs::remove_dir_all(target)?;
            }
            Ok(ConflictAction::Proceed)
        }
        OnConflict::Backup => {
            // Create backup: file.txt -> file.txt.bak, file -> file.bak
            let backup_path = match target.extension() {
                Some(ext) => target.with_extension(format!("{}.bak", ext.to_string_lossy())),
                None => target.with_extension("bak"),
            };
            std::fs::rename(target, &backup_path)?;
            Ok(ConflictAction::Proceed)
        }
    }
}

#[cfg(all(test, feature = "impure-test"))]
mod tests {
    use super::*;

    use tempfile::TempDir;

    #[test]
    fn test_check_conflict_exists() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("existing.txt");
        std::fs::write(&file, "content").unwrap();

        assert!(check_conflict(&file));
    }

    #[test]
    fn test_check_conflict_not_exists() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("nonexistent.txt");

        assert!(!check_conflict(&file));
    }

    #[test]
    fn test_resolve_conflict_abort() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("file.txt");
        std::fs::write(&file, "content").unwrap();

        let action = resolve_conflict(&file, OnConflict::Abort).unwrap();
        assert_eq!(action, ConflictAction::Abort);
        assert!(file.exists()); // File should still exist
    }

    #[test]
    fn test_resolve_conflict_skip() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("file.txt");
        std::fs::write(&file, "content").unwrap();

        let action = resolve_conflict(&file, OnConflict::Skip).unwrap();
        assert_eq!(action, ConflictAction::Skip);
        assert!(file.exists()); // File should still exist
    }

    #[test]
    fn test_resolve_conflict_overwrite() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("file.txt");
        std::fs::write(&file, "content").unwrap();

        let action = resolve_conflict(&file, OnConflict::Overwrite).unwrap();
        assert_eq!(action, ConflictAction::Proceed);
        assert!(!file.exists()); // File should be removed
    }

    #[test]
    fn test_resolve_conflict_backup() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("file.txt");
        std::fs::write(&file, "content").unwrap();

        let action = resolve_conflict(&file, OnConflict::Backup).unwrap();
        assert_eq!(action, ConflictAction::Proceed);
        assert!(!file.exists()); // Original should be moved
        assert!(temp.path().join("file.txt.bak").exists()); // Backup should exist
    }

    #[test]
    fn test_resolve_conflict_backup_no_extension() {
        let temp = TempDir::new().unwrap();
        let file = temp.path().join("Makefile");
        std::fs::write(&file, "content").unwrap();

        let action = resolve_conflict(&file, OnConflict::Backup).unwrap();
        assert_eq!(action, ConflictAction::Proceed);
        assert!(!file.exists());
        assert!(temp.path().join("Makefile.bak").exists());
    }
}