nedots 0.1.0

A small utility for managing configuration files & installing packages for Linux.
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

use std::path::{Path, PathBuf};

pub fn copy_file<'a>(
    from: &'a Path,
    to: &'a Path,
) -> std::io::Result<Result<PathBuf, &'static str>> {
    if let Some(file_name) = from.file_name() {
        if let Err(e) = std::fs::copy(
            from,
            format!("{}/{}", to.display(), file_name.to_string_lossy()),
        ) {
            return Err(e);
        }

        // The good result.
        return Ok(Ok(from.to_path_buf()));
    }

    // Bad but not the worst result, OS has not failed us, but we didn't
    // encounter a valid path to copy.
    Ok(Err(
        "Path did not contain a file or directory name, and instead ended in '..'",
    ))
}

/// Recursively copy all files found in `from` to `to`. `from` may contain
/// files or directories, as the function will walk directories to discover
/// files.
pub fn copy_files<'a>(
    from: Vec<&'a Path>,
    to: &'a Path,
) -> std::io::Result<Vec<Result<PathBuf, &'static str>>> {
    let mut list = Vec::new();
    for pb in from {
        match copy_file(&pb, to) {
            Ok(r) => match r {
                Ok(p) => list.push(Ok(p)),
                Err(e) => list.push(Err(e)),
            },
            Err(e) => return Err(e),
        }
    }

    Ok(list)
}

/// A helper struct for performing copy operations.
pub struct CopyOperation {
    /// Paths that will be copied to some destination (dest is specified when
    /// `copy` is called.)
    pub paths: Vec<PathBuf>,
    /// Tracks status of each copy operation in a vec containing a tuple - left
    /// side is the status, and right side is the original path.
    pub results: Vec<Result<PathBuf, &'static str>>,
}

impl CopyOperation {
    /// Create a new `CopyOperation` with `paths`.
    pub fn new(paths: Vec<PathBuf>) -> Self {
        Self {
            paths,
            results: Vec::new(),
        }
    }

    /// Create a `CopyOperation` from a single `PathBuf`.
    pub fn only(path: PathBuf) -> Self {
        Self {
            paths: vec![path],
            results: Vec::new(),
        }
    }

    /// Recursively copies all files found in `self.paths`, walking
    /// sub-directories as it goes, to `dest`.
    pub fn copy_to(&mut self, dest: &Path) -> std::io::Result<()> {
        match copy_files(self.paths.iter().map(|pb| pb.as_path()).collect(), dest) {
            Ok(v) => {
                self.results = v;
                Ok(())
            }
            Err(e) => Err(e),
        }
    }
}

impl From<Vec<&Path>> for CopyOperation {
    fn from(vec: Vec<&Path>) -> Self {
        Self {
            paths: vec.iter().map(|p| p.into()).collect(),
            results: Vec::new(),
        }
    }
}

impl From<&Path> for CopyOperation {
    fn from(path: &Path) -> Self {
        CopyOperation::only(path.into())
    }
}

#[cfg(test)]
mod tests {}