Skip to main content

murk_cli/
git.rs

1//! Git integration helpers (merge driver setup).
2
3use std::fs;
4use std::io::Write;
5use std::path::Path;
6use std::process::Command;
7
8/// The `.gitattributes` line that enables the merge driver.
9const GITATTRIBUTES_LINE: &str = "*.murk merge=murk";
10
11/// Git config keys for the merge driver.
12const GIT_CONFIG_MERGE_NAME: &str = "merge.murk.name";
13const GIT_CONFIG_MERGE_DRIVER: &str = "merge.murk.driver";
14
15/// A step completed during merge driver setup.
16#[derive(Debug, PartialEq, Eq)]
17pub enum MergeDriverSetupStep {
18    /// `.gitattributes` already contained the merge driver entry.
19    GitattributesAlreadyExists,
20    /// Appended the merge driver entry to an existing `.gitattributes`.
21    GitattributesAppended,
22    /// Created a new `.gitattributes` file with the merge driver entry.
23    GitattributesCreated,
24    /// Configured `git config merge.murk.*`.
25    GitConfigured,
26}
27
28/// Configure git to use murk's custom merge driver for `.murk` files.
29///
30/// 1. Ensures `.gitattributes` contains `*.murk merge=murk`.
31/// 2. Runs `git config merge.murk.name` and `git config merge.murk.driver`.
32///
33/// Returns the steps that were performed.
34pub fn setup_merge_driver() -> Result<Vec<MergeDriverSetupStep>, String> {
35    let mut steps = Vec::new();
36
37    // 1. Write .gitattributes entry.
38    let gitattributes = Path::new(".gitattributes");
39    let merge_line = GITATTRIBUTES_LINE;
40
41    crate::env::reject_symlink(gitattributes, ".gitattributes")?;
42
43    if gitattributes.exists() {
44        let contents = fs::read_to_string(gitattributes)
45            .map_err(|e| format!("reading .gitattributes: {e}"))?;
46        if contents.contains(merge_line) {
47            steps.push(MergeDriverSetupStep::GitattributesAlreadyExists);
48        } else {
49            let mut file = fs::OpenOptions::new()
50                .append(true)
51                .open(gitattributes)
52                .map_err(|e| format!("writing .gitattributes: {e}"))?;
53            writeln!(file, "{merge_line}").map_err(|e| format!("writing .gitattributes: {e}"))?;
54            steps.push(MergeDriverSetupStep::GitattributesAppended);
55        }
56    } else {
57        fs::write(gitattributes, format!("{merge_line}\n"))
58            .map_err(|e| format!("writing .gitattributes: {e}"))?;
59        steps.push(MergeDriverSetupStep::GitattributesCreated);
60    }
61
62    // 2. Configure git merge driver.
63    let configs = [
64        (GIT_CONFIG_MERGE_NAME, "murk vault merge"),
65        (GIT_CONFIG_MERGE_DRIVER, "murk merge-driver %O %A %B"),
66    ];
67    for (key, value) in &configs {
68        let status = Command::new("git")
69            .args(["config", key, value])
70            .status()
71            .map_err(|e| format!("running git config: {e}"))?;
72        if !status.success() {
73            return Err(format!("git config {key} failed (are you in a git repo?)"));
74        }
75    }
76    steps.push(MergeDriverSetupStep::GitConfigured);
77
78    Ok(steps)
79}
80
81#[cfg(test)]
82mod tests {
83    use super::*;
84    use crate::testutil::CWD_LOCK;
85
86    #[test]
87    fn setup_merge_driver_creates_gitattributes() {
88        let _lock = CWD_LOCK
89            .lock()
90            .unwrap_or_else(std::sync::PoisonError::into_inner);
91        let dir = std::env::temp_dir().join("murk_test_git_setup");
92        let _ = std::fs::remove_dir_all(&dir);
93        std::fs::create_dir_all(&dir).unwrap();
94
95        // Init a git repo so git config works.
96        Command::new("git")
97            .args(["init"])
98            .current_dir(&dir)
99            .output()
100            .unwrap();
101
102        let original_dir = std::env::current_dir().unwrap();
103        std::env::set_current_dir(&dir).unwrap();
104
105        let steps = setup_merge_driver().unwrap();
106        assert!(steps.contains(&MergeDriverSetupStep::GitattributesCreated));
107        assert!(steps.contains(&MergeDriverSetupStep::GitConfigured));
108
109        let contents = std::fs::read_to_string(dir.join(".gitattributes")).unwrap();
110        assert!(contents.contains("*.murk merge=murk"));
111
112        std::env::set_current_dir(original_dir).unwrap();
113        std::fs::remove_dir_all(&dir).unwrap();
114    }
115
116    #[test]
117    fn setup_merge_driver_appends_gitattributes() {
118        let _lock = CWD_LOCK
119            .lock()
120            .unwrap_or_else(std::sync::PoisonError::into_inner);
121        let dir = std::env::temp_dir().join("murk_test_git_append");
122        let _ = std::fs::remove_dir_all(&dir);
123        std::fs::create_dir_all(&dir).unwrap();
124
125        Command::new("git")
126            .args(["init"])
127            .current_dir(&dir)
128            .output()
129            .unwrap();
130
131        std::fs::write(dir.join(".gitattributes"), "*.txt text\n").unwrap();
132
133        let original_dir = std::env::current_dir().unwrap();
134        std::env::set_current_dir(&dir).unwrap();
135
136        let steps = setup_merge_driver().unwrap();
137        assert!(steps.contains(&MergeDriverSetupStep::GitattributesAppended));
138
139        let contents = std::fs::read_to_string(dir.join(".gitattributes")).unwrap();
140        assert!(contents.contains("*.txt text"));
141        assert!(contents.contains("*.murk merge=murk"));
142
143        std::env::set_current_dir(original_dir).unwrap();
144        std::fs::remove_dir_all(&dir).unwrap();
145    }
146
147    #[test]
148    fn setup_merge_driver_already_exists() {
149        let _lock = CWD_LOCK
150            .lock()
151            .unwrap_or_else(std::sync::PoisonError::into_inner);
152        let dir = std::env::temp_dir().join("murk_test_git_exists");
153        let _ = std::fs::remove_dir_all(&dir);
154        std::fs::create_dir_all(&dir).unwrap();
155
156        Command::new("git")
157            .args(["init"])
158            .current_dir(&dir)
159            .output()
160            .unwrap();
161
162        std::fs::write(dir.join(".gitattributes"), "*.murk merge=murk\n").unwrap();
163
164        let original_dir = std::env::current_dir().unwrap();
165        std::env::set_current_dir(&dir).unwrap();
166
167        let steps = setup_merge_driver().unwrap();
168        assert!(steps.contains(&MergeDriverSetupStep::GitattributesAlreadyExists));
169
170        std::env::set_current_dir(original_dir).unwrap();
171        std::fs::remove_dir_all(&dir).unwrap();
172    }
173}