rft-cli 0.4.1

Zero-config Docker Compose isolation for git worktrees
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::path::Path;
use std::process::Output;

use owo_colors::OwoColorize;

use crate::error::Result;

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Executor {
    Real,
    DryRun,
}

impl Executor {
    pub fn is_dry_run(&self) -> bool {
        *self == Self::DryRun
    }

    pub async fn copy_file(&self, source: &Path, target: &Path) -> Result<()> {
        match self {
            Self::Real => {
                if let Some(parent) = target.parent() {
                    tokio::fs::create_dir_all(parent).await?;
                }
                tokio::fs::copy(source, target).await?;
                Ok(())
            }
            Self::DryRun => {
                println!(
                    "  {} {} → {}",
                    "copy".dimmed(),
                    source.display(),
                    target.display()
                );
                Ok(())
            }
        }
    }

    pub async fn write_file(&self, path: &Path, content: &str) -> Result<()> {
        match self {
            Self::Real => {
                if let Some(parent) = path.parent() {
                    tokio::fs::create_dir_all(parent).await?;
                }
                tokio::fs::write(path, content).await?;
                Ok(())
            }
            Self::DryRun => {
                println!(
                    "  {} {} ({} bytes)",
                    "write".dimmed(),
                    path.display(),
                    content.len()
                );
                Ok(())
            }
        }
    }

    pub async fn create_dir_all(&self, path: &Path) -> Result<()> {
        match self {
            Self::Real => {
                tokio::fs::create_dir_all(path).await?;
                Ok(())
            }
            Self::DryRun => {
                println!("  {} {}", "mkdir".dimmed(), path.display());
                Ok(())
            }
        }
    }

    pub async fn run_docker(&self, args: &[&str], cwd: &Path) -> Result<Option<Output>> {
        match self {
            Self::Real => {
                let output = tokio::process::Command::new("docker")
                    .args(args)
                    .current_dir(cwd)
                    .output()
                    .await?;
                Ok(Some(output))
            }
            Self::DryRun => {
                println!("  {} docker {}", "exec".dimmed(), args.join(" "));
                Ok(None)
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn executor_is_dry_run() {
        assert!(!Executor::Real.is_dry_run());
        assert!(Executor::DryRun.is_dry_run());
    }

    #[tokio::test]
    async fn dry_run_copy_does_not_create_files() {
        let dir = tempfile::tempdir().unwrap();
        let source = dir.path().join("source.txt");
        let target = dir.path().join("target.txt");
        tokio::fs::write(&source, "data").await.unwrap();

        Executor::DryRun.copy_file(&source, &target).await.unwrap();

        assert!(!target.exists());
    }

    #[tokio::test]
    async fn real_copy_creates_files() {
        let dir = tempfile::tempdir().unwrap();
        let source = dir.path().join("source.txt");
        let target = dir.path().join("sub/target.txt");
        tokio::fs::write(&source, "data").await.unwrap();

        Executor::Real.copy_file(&source, &target).await.unwrap();

        assert_eq!(tokio::fs::read_to_string(&target).await.unwrap(), "data");
    }

    #[tokio::test]
    async fn dry_run_write_does_not_create_files() {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("file.txt");

        Executor::DryRun.write_file(&path, "content").await.unwrap();

        assert!(!path.exists());
    }

    #[tokio::test]
    async fn dry_run_docker_returns_none() {
        let dir = tempfile::tempdir().unwrap();
        let result = Executor::DryRun
            .run_docker(&["ps"], dir.path())
            .await
            .unwrap();

        assert!(result.is_none());
    }
}