archive-rs 0.0.2

archive file library
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

#[cfg(feature = "tar")]
use std::fs::File;
#[cfg(feature = "zstd")]
use std::io::BufReader;
use std::path::Path;

use path_utils::PathExt;

#[cfg(feature = "bzip2")]
use bzip2::read::BzDecoder as BzSysDecoder;
#[cfg(feature = "bzip2-rs")]
use bzip2_rs::decoder::DecoderReader as BzNativeDecoder;
#[cfg(feature = "flate2")]
use flate2::read::GzDecoder;
#[cfg(feature = "lz4")]
use lz4::Decoder as Lz4Decoder;
#[cfg(feature = "tar")]
use tar::Archive as Tar;
#[cfg(feature = "xz2")]
use xz2::read::XzDecoder;
#[cfg(feature = "zstd")]
use zstd::stream::read::Decoder as ZstdDecoder;

use crate::Result;

/// Archive file.
// NONEXHAUSTIVE new formats could add new types
#[non_exhaustive]
// ALLOW constructing and storing Self is not the bottleneck, iterating the
// entries and I/O is
#[allow(clippy::large_enum_variant)]
pub enum Archive {
    #[cfg(feature = "tar")]
    #[doc(hidden)]
    Tar(Tar<File>),

    #[cfg(all(feature = "bzip2", feature = "tar"))]
    #[doc(hidden)]
    TarBzip2(Tar<BzSysDecoder<File>>),

    #[cfg(all(feature = "bzip2-rs", feature = "tar"))]
    #[doc(hidden)]
    TarBzip2Rs(Tar<BzNativeDecoder<File>>),

    #[cfg(all(feature = "flate2", feature = "tar"))]
    #[doc(hidden)]
    TarGzip(Tar<GzDecoder<File>>),

    #[cfg(all(feature = "lz4", feature = "tar"))]
    #[doc(hidden)]
    TarLz4(Tar<Lz4Decoder<File>>),

    #[cfg(all(feature = "xz2", feature = "tar"))]
    #[doc(hidden)]
    TarXz(Tar<XzDecoder<File>>),

    #[cfg(all(feature = "zstd", feature = "tar"))]
    #[doc(hidden)]
    TarZstd(Tar<ZstdDecoder<'static, BufReader<File>>>),
}

impl Archive {
    /// Returns an opened archive file.
    ///
    /// # Errors
    ///
    /// Returns an error if archive is of unsupported format or if opening it
    /// fails.
    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
        let path = path.as_ref();

        let extensions: Vec<String> = path.extensions_lossy().collect();
        let extensions: Vec<&str> =
            extensions.iter().map(String::as_str).collect();

        match extensions.as_slice() {
            #[cfg(all(feature = "bzip2", feature = "tar"))]
            ["tbz" | "tbz2", ..] | ["bz2", "tar", ..] => {
                let file = File::open(path)?;
                let file = BzSysDecoder::new(file);
                Ok(Self::TarBzip2(Tar::new(file)))
            }

            #[cfg(all(feature = "bzip2-rs", feature = "tar"))]
            ["tbz" | "tbz2", ..] | ["bz2", "tar", ..] => {
                let file = File::open(path)?;
                let file = BzNativeDecoder::new(file);
                Ok(Self::TarBzip2Rs(Tar::new(file)))
            }

            #[cfg(all(feature = "flate2", feature = "tar"))]
            ["tgz", ..] | ["gz", "tar", ..] => {
                let file = File::open(path)?;
                let file = GzDecoder::new(file);
                Ok(Self::TarGzip(Tar::new(file)))
            }

            #[cfg(all(feature = "lz4", feature = "tar"))]
            ["lz4", "tar", ..] => {
                let file = File::open(path)?;
                let file = Lz4Decoder::new(file)?;
                Ok(Self::TarLz4(Tar::new(file)))
            }

            #[cfg(all(feature = "xz2", feature = "tar"))]
            ["txz", ..] | ["xz", "tar", ..] => {
                let file = File::open(path)?;
                let file = XzDecoder::new(file);
                Ok(Self::TarXz(Tar::new(file)))
            }

            #[cfg(all(feature = "zstd", feature = "tar"))]
            ["zst", "tar", ..] => {
                let file = File::open(path)?;
                let file = ZstdDecoder::new(file)?;
                Ok(Self::TarZstd(Tar::new(file)))
            }

            #[cfg(feature = "tar")]
            ["tar", ..] => {
                let file = File::open(path)?;
                Ok(Self::Tar(Tar::new(file)))
            }

            _ => Err(crate::Error::UnsupportedArchiveType(path.to_path_buf())),
        }
    }
}