read-url 0.0.10

Read from a wide variety of URL types
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

use super::{
    super::{context::*, errors::*, url::*, util::*},
    compression::*,
};

use {
    relative_path::*,
    std::{fmt, sync::*},
};

//
// TarUrl
//

/// A URL for an entry in a tarball (tar archive).
///
/// Supports bare as well as compressed tarballs.
///
/// The URL scheme is "tar:", followed by full archive URL, a `!`, and then the entry path
/// within the archive. The fragment of the archive URL is used to explicitly set the
/// compression algorithm. If the compression is not explicitly set, will attempt to determine
/// it according to the format of the archive URL.
#[derive(Clone, Debug)]
pub struct TarUrl {
    /// The archive [URL].
    pub archive_url: Arc<UrlRef>,

    /// The entry path.
    pub path: RelativePathBuf,

    /// Compression.
    pub compression: Option<TarCompression>,

    pub(crate) context: UrlContextRef,
}

impl TarUrl {
    /// Parse.
    pub fn parse(url_representation: &str) -> Result<(String, String), UrlError> {
        parse_archive_entry_url_representation(url_representation, "tar")
    }

    /// Compression from archive URL fragment.
    pub fn compression_from(archive_url: &UrlRef) -> Result<Option<TarCompression>, UrlError> {
        Ok(match archive_url.fragment() {
            Some(fragment) => Some(fragment.parse()?),
            None => None,
        })
    }

    /// Constructor.
    pub fn new(
        context: &UrlContextRef,
        archive_url: Arc<UrlRef>,
        path: RelativePathBuf,
        compression: Option<TarCompression>,
    ) -> Self {
        Self { archive_url, path, compression, context: context.clone() }
    }

    /// Constructor.
    pub fn new_with(&self, path: RelativePathBuf) -> TarUrl {
        Self::new(&self.context, self.archive_url.clone(), path, self.compression.clone())
    }

    #[cfg(any(feature = "blocking", feature = "async"))]
    pub(crate) fn get_compression(&self) -> TarCompression {
        match &self.compression {
            Some(compression) => compression.clone(),

            None => match self.archive_url.format() {
                Some(archive_format) => match archive_format.as_str() {
                    "tar.gz" => TarCompression::Gzip,
                    "tar.zstd" => TarCompression::Zstandard,
                    _ => TarCompression::None,
                },

                _ => TarCompression::None,
            },
        }
    }
}

impl fmt::Display for TarUrl {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "tar:{}!{}", self.archive_url, self.path)
    }
}

// Conversions

impl Into<UrlRef> for TarUrl {
    fn into(self) -> UrlRef {
        Box::new(self)
    }
}