totebag 0.8.14

An API for extracting/archiving files and directories in multiple formats.
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

use std::fs::File;
use std::path::PathBuf;

use crate::archiver::{ArchiveEntry, ToteArchiver};
use crate::{Result, Error};

/// CPIO format archiver implementation.
///
/// This archiver creates CPIO archive files.
pub(super) struct Archiver {}

impl ToteArchiver for Archiver {
    fn perform(&self, file: File, targets: &[PathBuf], config: &crate::ArchiveConfig) -> Result<Vec<ArchiveEntry>> {
        let entries = super::collect_entries(targets, config);
        let format = find_format(config.level);
        let mut builder = cpio::Builder::new(file);
        builder.set_format(format);
        let mut errs = vec![];
        for path in entries.iter() {
            let path_in_archive = config.path_in_archive(path);
            if let Err(e) = builder.append_path(path, &path_in_archive) {
                errs.push(Error::Archiver(e.to_string()));
            };
        }
        match builder.finish() {
            Ok(_) => Ok(entries.into_iter().map(ArchiveEntry::from).collect()),
            Err(e) => {
                errs.push(Error::Archiver(e.to_string()));
                Error::error_or_else(Vec::new, errs)
            },
        }
    }

    fn enable(&self) -> bool {
        true
    }
}

fn find_format(level: u8) -> cpio::Format {
    use cpio::ByteOrder::{LittleEndian, BigEndian};
    match level {
        0..=3 => cpio::Format::Odc,
        4..=6 => cpio::Format::Newc,
        7 => cpio::Format::Crc,
        8 => cpio::Format::Bin(LittleEndian),
        9 => cpio::Format::Bin(BigEndian),
        _ => cpio::Format::Newc,
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    fn run_test<F>(f: F)
    where
        F: FnOnce(),
    {
        // setup(); // preprocessing
        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f));
        teardown(); // postprocessing

        if let Err(err) = result {
            std::panic::resume_unwind(err);
        }
    }

    #[test]
    fn test_archive() {
        run_test(|| {
            let config = crate::ArchiveConfig::builder()
                .dest("results/test.cpio")
                .overwrite(false)
                .no_recursive(true)
                .build();
            let v = vec!["lib", "cli", "Cargo.toml"]
                .into_iter()
                .map(|s| PathBuf::from(s))
                .collect::<Vec<_>>();
            if let Err(e) = crate::archive(&v, &config) {
                panic!("{e:?}")
            }
        });
    }

    fn teardown() {
        let _ = std::fs::remove_file("results/test.cpio");
    }
}