cmprss 0.2.0

A compression multi-tool for the command line.
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

extern crate tar;

use clap::Args;
use std::fs::File;
use std::io::{self, Read, Write};
use std::path::Path;
use tar::{Archive, Builder};

use crate::utils::*;

#[derive(Args, Debug)]
pub struct TarArgs {
    #[clap(flatten)]
    pub common_args: CommonArgs,
}

#[derive(Default)]
pub struct Tar {}

impl Tar {
    pub fn new(_args: &TarArgs) -> Tar {
        Tar {}
    }
}

impl Compressor for Tar {
    /// Full name for tar, also used for extension
    fn name(&self) -> &str {
        "tar"
    }

    /// Tar extraction needs to specify the directory, so use the current directory
    fn default_extracted_filename(&self, _in_path: &Path) -> String {
        ".".to_string()
    }

    fn compress(&self, input: CmprssInput, output: CmprssOutput) -> Result<(), io::Error> {
        match output {
            CmprssOutput::Pipe(pipe) => self.compress_internal(input, Builder::new(pipe)),
            CmprssOutput::Path(path) => {
                self.compress_internal(input, Builder::new(File::create(path)?))
            }
        }
    }

    fn extract(&self, input: CmprssInput, output: CmprssOutput) -> Result<(), io::Error> {
        match input {
            CmprssInput::Path(paths) => {
                if paths.len() > 1 {
                    return cmprss_error("only 1 archive can be extracted at a time");
                }
                self.extract_internal(Archive::new(File::open(paths[0].as_path())?), output)
            }
            CmprssInput::Pipe(pipe) => self.extract_internal(Archive::new(pipe), output),
        }
    }
}

impl Tar {
    /// Internal extract helper
    fn extract_internal<R: Read>(
        &self,
        mut archive: Archive<R>,
        output: CmprssOutput,
    ) -> Result<(), io::Error> {
        let out_path = match output {
            CmprssOutput::Pipe(_) => {
                return cmprss_error("error: tar does not support stdout as extract output")
            }
            CmprssOutput::Path(path) => path,
        };
        if !out_path.is_dir() {
            return cmprss_error("error: tar can only extract to a directory");
        }
        archive.unpack(out_path)
    }

    /// Internal compress helper
    fn compress_internal<W: Write>(
        &self,
        input: CmprssInput,
        mut archive: Builder<W>,
    ) -> Result<(), io::Error> {
        let input_files = match input {
            CmprssInput::Path(paths) => paths,
            CmprssInput::Pipe(_) => {
                return cmprss_error("error: tar does not support stdin as input")
            }
        };
        for in_file in input_files {
            if in_file.is_file() {
                archive.append_file(
                    in_file.file_name().unwrap(),
                    &mut File::open(in_file.as_path())?,
                )?;
            } else if in_file.is_dir() {
                archive.append_dir_all(in_file.file_name().unwrap(), in_file.as_path())?;
            } else {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    "unknown file type",
                ));
            }
        }
        archive.finish()
    }
}

// TODO: Tests will be largely the same for all Compressors, should be able to combine
#[cfg(test)]
mod tests {
    use super::*;
    use assert_fs::prelude::*;
    use predicates::prelude::*;

    #[test]
    fn roundtrip() -> Result<(), Box<dyn std::error::Error>> {
        let compressor = Tar::default();

        let file = assert_fs::NamedTempFile::new("test.txt")?;
        file.write_str("garbage data for testing")?;
        let working_dir = assert_fs::TempDir::new()?;
        let archive = working_dir.child("archive.".to_owned() + compressor.extension());
        archive.assert(predicate::path::missing());

        // Roundtrip compress/extract
        compressor.compress(
            CmprssInput::Path(vec![file.path().to_path_buf()]),
            CmprssOutput::Path(archive.path().to_path_buf()),
        )?;
        archive.assert(predicate::path::is_file());
        compressor.extract(
            CmprssInput::Path(vec![archive.path().to_path_buf()]),
            CmprssOutput::Path(working_dir.path().to_path_buf()),
        )?;

        // Assert the files are identical
        working_dir
            .child("test.txt")
            .assert(predicate::path::eq_file(file.path()));

        Ok(())
    }
}