repo-cli 0.1.3

A sane way to manage all of your git repositories
Documentation 
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

use anyhow::{Context, Result};
use std::{
    borrow::Borrow,
    fs::{File, OpenOptions},
    io::Read,
    path::{Path, PathBuf},
};

pub fn make_path_buf<S: AsRef<str>>(s: S) -> Result<PathBuf> {
    shellexpand::full(s.as_ref())
        .map(|s| PathBuf::from(s.borrow() as &str))
        .map_err(Into::into)
}

pub fn read_content<P>(path: P) -> Result<String>
where
    P: AsRef<Path> + std::fmt::Debug,
{
    let mut content = String::new();
    File::open(&path)
        .context(format!("failed to open file: {:#?}", path))?
        .read_to_string(&mut content)
        .context(format!("failed to read file: '{:#?}'", path))?;

    Ok(content)
}

pub fn write_content<P, F>(path: P, write_fn: F) -> Result<()>
where
    P: AsRef<Path>,
    F: FnOnce(&mut File) -> Result<()>,
{
    std::fs::create_dir_all(path.as_ref().parent().unwrap())?;
    let mut file = OpenOptions::new()
        .write(true)
        .create(true)
        .truncate(true)
        .open(&path)?;
    write_fn(&mut file)
}

pub mod process {
    use anyhow::{Context, Result};
    use std::{
        io::{BufRead, BufReader},
        process::{Command, ExitStatus, Stdio},
    };

    pub fn inherit(name: &str) -> Command {
        let mut command = Command::new(name);
        command.stdin(Stdio::inherit());
        command.stdout(Stdio::inherit());
        command.stderr(Stdio::inherit());
        command
    }

    pub fn piped(name: &str) -> Command {
        let mut command = Command::new(name);
        command.stdin(Stdio::piped());
        command.stdout(Stdio::piped());
        command.stderr(Stdio::piped());
        command
    }

    pub fn null(name: &str) -> Command {
        let mut command = Command::new(name);
        command.stdin(Stdio::null());
        command.stdout(Stdio::null());
        command.stderr(Stdio::null());
        command
    }

    pub fn execute_command(command: &mut Command, prefix: String) -> Result<ExitStatus> {
        let mut child = command
            .spawn()
            .context("failed executing command as a child process")?;

        let stdout_child = if let Some(stdout) = child.stdout.take() {
            let pre = prefix.clone();
            Some(std::thread::spawn(move || forward_stdout(stdout, &pre)))
        } else {
            None
        };

        if let Some(stderr) = child.stderr.take() {
            forward_stdout(stderr, &prefix).context("could not forward stderr to stdout")?;
        }

        if let Some(child_thread) = stdout_child {
            child_thread
                .join()
                .expect("failed to join stdout child thread with main thread")?;
        }

        child.wait().map_err(Into::into)
    }

    fn forward_stdout<T>(read: T, prefix: &str) -> Result<()>
    where
        T: std::io::Read,
    {
        let mut buffer = BufReader::new(read);
        loop {
            let mut line = String::new();
            let result = buffer
                .read_line(&mut line)
                .context("could not read buffered line")?;
            if result == 0 {
                break;
            }

            // TODO: Have computed the larget string before calling this
            // but format does not allow formatting with dynamic variables.
            // This means that I cant format left based on the max_size
            let prefix = format!("{:>20.20} |", prefix);
            print!("{} {}", prefix, line);
        }

        Ok(())
    }
}

#[cfg(not(windows))]
pub fn canonicalize<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
    path.as_ref().canonicalize().map_err(Into::into)
}

#[cfg(windows)]
pub fn canonicalize<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
    path.as_ref()
        .canonicalize()
        .map_err(Into::into)
        .map(|path| {
            path.to_string_lossy()
                .trim_start_matches(r"\\?\")
                .replace("\\", "/")
        })
        .map(PathBuf::from)
}