paq 1.4.1

Hash file or directory recursively.
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

use std::env;
use std::error;
use std::fs::{self};
#[cfg(target_family = "unix")]
use std::os::unix::fs::symlink;
use std::path::{Path, PathBuf};
use std::result;

pub const TEMP_DIRECTORY_NAME: &str = "paq";

/// A convenient result type alias.
pub type Result<T> = result::Result<T, Box<dyn error::Error + Send + Sync>>;

/// Create an error from a format!-like syntax.
#[macro_export]
macro_rules! err {
    ($($tt:tt)*) => {
        Box::<dyn error::Error + Send + Sync>::from(format!($($tt)*))
    }
}

/// A simple wrapper for creating a temporary directory that is automatically
/// deleted when it's dropped.
///
/// We use this in lieu of tempfile because tempfile brings in too many
/// dependencies.
#[derive(Debug)]
pub struct TempDir(PathBuf);

#[cfg(feature = "test-cleanup")]
impl Drop for TempDir {
    fn drop(&mut self) {
        fs::remove_dir_all(&self.0).unwrap();
    }
}

impl TempDir {
    /// Create a new empty temporary directory under the system's configured
    /// temporary directory.
    pub fn new(name: &str) -> Result<TempDir> {
        static TRIES: usize = 100;

        let tmpdir = env::temp_dir();
        for _ in 0..TRIES {
            let root_path = tmpdir.join(TEMP_DIRECTORY_NAME);
            let iteration_path = root_path.join(name);
            if iteration_path.is_dir() {
                continue;
            }
            fs::create_dir_all(&iteration_path)
                .map_err(|e| err!("failed to create {}: {}", iteration_path.display(), e))?;
            return Ok(TempDir(iteration_path));
        }
        Err(err!("failed to create temp dir after {} tries", TRIES))
    }

    /// Create a new file in temporary directory using data of byte array.
    pub fn new_file(&self, name: &str, data: &[u8]) -> Result<()> {
        let file_path = PathBuf::from(format!("{}/{}", self.path().display(), name));
        fs::write(file_path.as_os_str(), data).expect("Unable to write file");
        Ok(())
    }

    /// Read a file in temporary directory.
    pub fn read_file(&self, name: &str) -> Result<Vec<u8>> {
        let file_path = PathBuf::from(format!("{}/{}", self.path().display(), name));
        Ok(fs::read(file_path.as_os_str()).expect("Unable to read file"))
    }

    /// Create a new symlink in temporary directory to target.
    #[cfg(target_family = "unix")]
    pub fn new_symlink(&self, name: &str, target: PathBuf) -> Result<()> {
        let symlink_path = PathBuf::from(format!("{}/{}", self.path().display(), name));
        symlink(target.as_os_str(), symlink_path.as_os_str())
        .expect("Unable to create symlink");
        Ok(
            (),
        )
    }

    /// Return the underlying path to this temporary directory.
    pub fn path(&self) -> &Path {
        &self.0
    }
}