Deleted vendor folder

1 files changed, 0 insertions, 644 deletions

diff --git a/vendor/flate2/src/gz/mod.rs b/vendor/flate2/src/gz/mod.rs
deleted file mode 100644
index 31a6961..0000000
--- a/vendor/flate2/src/gz/mod.rs
+++ /dev/null
@@ -1,644 +0,0 @@
-use std::ffi::CString;
-use std::io::{BufRead, Error, ErrorKind, Read, Result, Write};
-use std::time;
-
-use crate::bufreader::BufReader;
-use crate::{Compression, Crc};
-
-pub static FHCRC: u8 = 1 << 1;
-pub static FEXTRA: u8 = 1 << 2;
-pub static FNAME: u8 = 1 << 3;
-pub static FCOMMENT: u8 = 1 << 4;
-pub static FRESERVED: u8 = 1 << 5 | 1 << 6 | 1 << 7;
-
-pub mod bufread;
-pub mod read;
-pub mod write;
-
-// The maximum length of the header filename and comment fields. More than
-// enough for these fields in reasonable use, but prevents possible attacks.
-const MAX_HEADER_BUF: usize = 65535;
-
-/// A structure representing the header of a gzip stream.
-///
-/// The header can contain metadata about the file that was compressed, if
-/// present.
-#[derive(PartialEq, Clone, Debug, Default)]
-pub struct GzHeader {
-    extra: Option<Vec<u8>>,
-    filename: Option<Vec<u8>>,
-    comment: Option<Vec<u8>>,
-    operating_system: u8,
-    mtime: u32,
-}
-
-impl GzHeader {
-    /// Returns the `filename` field of this gzip stream's header, if present.
-    pub fn filename(&self) -> Option<&[u8]> {
-        self.filename.as_ref().map(|s| &s[..])
-    }
-
-    /// Returns the `extra` field of this gzip stream's header, if present.
-    pub fn extra(&self) -> Option<&[u8]> {
-        self.extra.as_ref().map(|s| &s[..])
-    }
-
-    /// Returns the `comment` field of this gzip stream's header, if present.
-    pub fn comment(&self) -> Option<&[u8]> {
-        self.comment.as_ref().map(|s| &s[..])
-    }
-
-    /// Returns the `operating_system` field of this gzip stream's header.
-    ///
-    /// There are predefined values for various operating systems.
-    /// 255 means that the value is unknown.
-    pub fn operating_system(&self) -> u8 {
-        self.operating_system
-    }
-
-    /// This gives the most recent modification time of the original file being compressed.
-    ///
-    /// The time is in Unix format, i.e., seconds since 00:00:00 GMT, Jan. 1, 1970.
-    /// (Note that this may cause problems for MS-DOS and other systems that use local
-    /// rather than Universal time.) If the compressed data did not come from a file,
-    /// `mtime` is set to the time at which compression started.
-    /// `mtime` = 0 means no time stamp is available.
-    ///
-    /// The usage of `mtime` is discouraged because of Year 2038 problem.
-    pub fn mtime(&self) -> u32 {
-        self.mtime
-    }
-
-    /// Returns the most recent modification time represented by a date-time type.
-    /// Returns `None` if the value of the underlying counter is 0,
-    /// indicating no time stamp is available.
-    ///
-    ///
-    /// The time is measured as seconds since 00:00:00 GMT, Jan. 1 1970.
-    /// See [`mtime`](#method.mtime) for more detail.
-    pub fn mtime_as_datetime(&self) -> Option<time::SystemTime> {
-        if self.mtime == 0 {
-            None
-        } else {
-            let duration = time::Duration::new(u64::from(self.mtime), 0);
-            let datetime = time::UNIX_EPOCH + duration;
-            Some(datetime)
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum GzHeaderState {
-    Start(u8, [u8; 10]),
-    Xlen(Option<Box<Crc>>, u8, [u8; 2]),
-    Extra(Option<Box<Crc>>, u16),
-    Filename(Option<Box<Crc>>),
-    Comment(Option<Box<Crc>>),
-    Crc(Option<Box<Crc>>, u8, [u8; 2]),
-    Complete,
-}
-
-impl Default for GzHeaderState {
-    fn default() -> Self {
-        Self::Complete
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct GzHeaderParser {
-    state: GzHeaderState,
-    flags: u8,
-    header: GzHeader,
-}
-
-impl GzHeaderParser {
-    fn new() -> Self {
-        GzHeaderParser {
-            state: GzHeaderState::Start(0, [0; 10]),
-            flags: 0,
-            header: GzHeader::default(),
-        }
-    }
-
-    fn parse<'a, R: Read>(&mut self, r: &'a mut R) -> Result<()> {
-        loop {
-            match &mut self.state {
-                GzHeaderState::Start(count, buffer) => {
-                    while (*count as usize) < buffer.len() {
-                        *count += read_into(r, &mut buffer[*count as usize..])? as u8;
-                    }
-                    // Gzip identification bytes
-                    if buffer[0] != 0x1f || buffer[1] != 0x8b {
-                        return Err(bad_header());
-                    }
-                    // Gzip compression method (8 = deflate)
-                    if buffer[2] != 8 {
-                        return Err(bad_header());
-                    }
-                    self.flags = buffer[3];
-                    // RFC1952: "must give an error indication if any reserved bit is non-zero"
-                    if self.flags & FRESERVED != 0 {
-                        return Err(bad_header());
-                    }
-                    self.header.mtime = ((buffer[4] as u32) << 0)
-                        | ((buffer[5] as u32) << 8)
-                        | ((buffer[6] as u32) << 16)
-                        | ((buffer[7] as u32) << 24);
-                    let _xfl = buffer[8];
-                    self.header.operating_system = buffer[9];
-                    let crc = if self.flags & FHCRC != 0 {
-                        let mut crc = Box::new(Crc::new());
-                        crc.update(buffer);
-                        Some(crc)
-                    } else {
-                        None
-                    };
-                    self.state = GzHeaderState::Xlen(crc, 0, [0; 2]);
-                }
-                GzHeaderState::Xlen(crc, count, buffer) => {
-                    if self.flags & FEXTRA != 0 {
-                        while (*count as usize) < buffer.len() {
-                            *count += read_into(r, &mut buffer[*count as usize..])? as u8;
-                        }
-                        if let Some(crc) = crc {
-                            crc.update(buffer);
-                        }
-                        let xlen = parse_le_u16(&buffer);
-                        self.header.extra = Some(vec![0; xlen as usize]);
-                        self.state = GzHeaderState::Extra(crc.take(), 0);
-                    } else {
-                        self.state = GzHeaderState::Filename(crc.take());
-                    }
-                }
-                GzHeaderState::Extra(crc, count) => {
-                    debug_assert!(self.header.extra.is_some());
-                    let extra = self.header.extra.as_mut().unwrap();
-                    while (*count as usize) < extra.len() {
-                        *count += read_into(r, &mut extra[*count as usize..])? as u16;
-                    }
-                    if let Some(crc) = crc {
-                        crc.update(extra);
-                    }
-                    self.state = GzHeaderState::Filename(crc.take());
-                }
-                GzHeaderState::Filename(crc) => {
-                    if self.flags & FNAME != 0 {
-                        let filename = self.header.filename.get_or_insert_with(Vec::new);
-                        read_to_nul(r, filename)?;
-                        if let Some(crc) = crc {
-                            crc.update(filename);
-                            crc.update(b"\0");
-                        }
-                    }
-                    self.state = GzHeaderState::Comment(crc.take());
-                }
-                GzHeaderState::Comment(crc) => {
-                    if self.flags & FCOMMENT != 0 {
-                        let comment = self.header.comment.get_or_insert_with(Vec::new);
-                        read_to_nul(r, comment)?;
-                        if let Some(crc) = crc {
-                            crc.update(comment);
-                            crc.update(b"\0");
-                        }
-                    }
-                    self.state = GzHeaderState::Crc(crc.take(), 0, [0; 2]);
-                }
-                GzHeaderState::Crc(crc, count, buffer) => {
-                    if let Some(crc) = crc {
-                        debug_assert!(self.flags & FHCRC != 0);
-                        while (*count as usize) < buffer.len() {
-                            *count += read_into(r, &mut buffer[*count as usize..])? as u8;
-                        }
-                        let stored_crc = parse_le_u16(&buffer);
-                        let calced_crc = crc.sum() as u16;
-                        if stored_crc != calced_crc {
-                            return Err(corrupt());
-                        }
-                    }
-                    self.state = GzHeaderState::Complete;
-                }
-                GzHeaderState::Complete => {
-                    return Ok(());
-                }
-            }
-        }
-    }
-
-    fn header(&self) -> Option<&GzHeader> {
-        match self.state {
-            GzHeaderState::Complete => Some(&self.header),
-            _ => None,
-        }
-    }
-}
-
-impl From<GzHeaderParser> for GzHeader {
-    fn from(parser: GzHeaderParser) -> Self {
-        debug_assert!(matches!(parser.state, GzHeaderState::Complete));
-        parser.header
-    }
-}
-
-// Attempt to fill the `buffer` from `r`. Return the number of bytes read.
-// Return an error if EOF is read before the buffer is full.  This differs
-// from `read` in that Ok(0) means that more data may be available.
-fn read_into<R: Read>(r: &mut R, buffer: &mut [u8]) -> Result<usize> {
-    debug_assert!(!buffer.is_empty());
-    match r.read(buffer) {
-        Ok(0) => Err(ErrorKind::UnexpectedEof.into()),
-        Ok(n) => Ok(n),
-        Err(ref e) if e.kind() == ErrorKind::Interrupted => Ok(0),
-        Err(e) => Err(e),
-    }
-}
-
-// Read `r` up to the first nul byte, pushing non-nul bytes to `buffer`.
-fn read_to_nul<R: Read>(r: &mut R, buffer: &mut Vec<u8>) -> Result<()> {
-    let mut bytes = r.bytes();
-    loop {
-        match bytes.next().transpose()? {
-            Some(byte) if byte == 0 => {
-                return Ok(());
-            }
-            Some(_) if buffer.len() == MAX_HEADER_BUF => {
-                return Err(Error::new(
-                    ErrorKind::InvalidInput,
-                    "gzip header field too long",
-                ));
-            }
-            Some(byte) => {
-                buffer.push(byte);
-            }
-            None => {
-                return Err(ErrorKind::UnexpectedEof.into());
-            }
-        }
-    }
-}
-
-fn parse_le_u16(buffer: &[u8; 2]) -> u16 {
-    (buffer[0] as u16) | ((buffer[1] as u16) << 8)
-}
-
-fn bad_header() -> Error {
-    Error::new(ErrorKind::InvalidInput, "invalid gzip header")
-}
-
-fn corrupt() -> Error {
-    Error::new(
-        ErrorKind::InvalidInput,
-        "corrupt gzip stream does not have a matching checksum",
-    )
-}
-
-/// A builder structure to create a new gzip Encoder.
-///
-/// This structure controls header configuration options such as the filename.
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// # use std::io;
-/// use std::fs::File;
-/// use flate2::GzBuilder;
-/// use flate2::Compression;
-///
-/// // GzBuilder opens a file and writes a sample string using GzBuilder pattern
-///
-/// # fn sample_builder() -> Result<(), io::Error> {
-/// let f = File::create("examples/hello_world.gz")?;
-/// let mut gz = GzBuilder::new()
-///                 .filename("hello_world.txt")
-///                 .comment("test file, please delete")
-///                 .write(f, Compression::default());
-/// gz.write_all(b"hello world")?;
-/// gz.finish()?;
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug)]
-pub struct GzBuilder {
-    extra: Option<Vec<u8>>,
-    filename: Option<CString>,
-    comment: Option<CString>,
-    operating_system: Option<u8>,
-    mtime: u32,
-}
-
-impl Default for GzBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl GzBuilder {
-    /// Create a new blank builder with no header by default.
-    pub fn new() -> GzBuilder {
-        GzBuilder {
-            extra: None,
-            filename: None,
-            comment: None,
-            operating_system: None,
-            mtime: 0,
-        }
-    }
-
-    /// Configure the `mtime` field in the gzip header.
-    pub fn mtime(mut self, mtime: u32) -> GzBuilder {
-        self.mtime = mtime;
-        self
-    }
-
-    /// Configure the `operating_system` field in the gzip header.
-    pub fn operating_system(mut self, os: u8) -> GzBuilder {
-        self.operating_system = Some(os);
-        self
-    }
-
-    /// Configure the `extra` field in the gzip header.
-    pub fn extra<T: Into<Vec<u8>>>(mut self, extra: T) -> GzBuilder {
-        self.extra = Some(extra.into());
-        self
-    }
-
-    /// Configure the `filename` field in the gzip header.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the `filename` slice contains a zero.
-    pub fn filename<T: Into<Vec<u8>>>(mut self, filename: T) -> GzBuilder {
-        self.filename = Some(CString::new(filename.into()).unwrap());
-        self
-    }
-
-    /// Configure the `comment` field in the gzip header.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the `comment` slice contains a zero.
-    pub fn comment<T: Into<Vec<u8>>>(mut self, comment: T) -> GzBuilder {
-        self.comment = Some(CString::new(comment.into()).unwrap());
-        self
-    }
-
-    /// Consume this builder, creating a writer encoder in the process.
-    ///
-    /// The data written to the returned encoder will be compressed and then
-    /// written out to the supplied parameter `w`.
-    pub fn write<W: Write>(self, w: W, lvl: Compression) -> write::GzEncoder<W> {
-        write::gz_encoder(self.into_header(lvl), w, lvl)
-    }
-
-    /// Consume this builder, creating a reader encoder in the process.
-    ///
-    /// Data read from the returned encoder will be the compressed version of
-    /// the data read from the given reader.
-    pub fn read<R: Read>(self, r: R, lvl: Compression) -> read::GzEncoder<R> {
-        read::gz_encoder(self.buf_read(BufReader::new(r), lvl))
-    }
-
-    /// Consume this builder, creating a reader encoder in the process.
-    ///
-    /// Data read from the returned encoder will be the compressed version of
-    /// the data read from the given reader.
-    pub fn buf_read<R>(self, r: R, lvl: Compression) -> bufread::GzEncoder<R>
-    where
-        R: BufRead,
-    {
-        bufread::gz_encoder(self.into_header(lvl), r, lvl)
-    }
-
-    fn into_header(self, lvl: Compression) -> Vec<u8> {
-        let GzBuilder {
-            extra,
-            filename,
-            comment,
-            operating_system,
-            mtime,
-        } = self;
-        let mut flg = 0;
-        let mut header = vec![0u8; 10];
-        if let Some(v) = extra {
-            flg |= FEXTRA;
-            header.push((v.len() >> 0) as u8);
-            header.push((v.len() >> 8) as u8);
-            header.extend(v);
-        }
-        if let Some(filename) = filename {
-            flg |= FNAME;
-            header.extend(filename.as_bytes_with_nul().iter().copied());
-        }
-        if let Some(comment) = comment {
-            flg |= FCOMMENT;
-            header.extend(comment.as_bytes_with_nul().iter().copied());
-        }
-        header[0] = 0x1f;
-        header[1] = 0x8b;
-        header[2] = 8;
-        header[3] = flg;
-        header[4] = (mtime >> 0) as u8;
-        header[5] = (mtime >> 8) as u8;
-        header[6] = (mtime >> 16) as u8;
-        header[7] = (mtime >> 24) as u8;
-        header[8] = if lvl.0 >= Compression::best().0 {
-            2
-        } else if lvl.0 <= Compression::fast().0 {
-            4
-        } else {
-            0
-        };
-
-        // Typically this byte indicates what OS the gz stream was created on,
-        // but in an effort to have cross-platform reproducible streams just
-        // default this value to 255. I'm not sure that if we "correctly" set
-        // this it'd do anything anyway...
-        header[9] = operating_system.unwrap_or(255);
-        header
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io::prelude::*;
-
-    use super::{read, write, GzBuilder, GzHeaderParser};
-    use crate::{Compression, GzHeader};
-    use rand::{thread_rng, Rng};
-
-    #[test]
-    fn roundtrip() {
-        let mut e = write::GzEncoder::new(Vec::new(), Compression::default());
-        e.write_all(b"foo bar baz").unwrap();
-        let inner = e.finish().unwrap();
-        let mut d = read::GzDecoder::new(&inner[..]);
-        let mut s = String::new();
-        d.read_to_string(&mut s).unwrap();
-        assert_eq!(s, "foo bar baz");
-    }
-
-    #[test]
-    fn roundtrip_zero() {
-        let e = write::GzEncoder::new(Vec::new(), Compression::default());
-        let inner = e.finish().unwrap();
-        let mut d = read::GzDecoder::new(&inner[..]);
-        let mut s = String::new();
-        d.read_to_string(&mut s).unwrap();
-        assert_eq!(s, "");
-    }
-
-    #[test]
-    fn roundtrip_big() {
-        let mut real = Vec::new();
-        let mut w = write::GzEncoder::new(Vec::new(), Compression::default());
-        let v = crate::random_bytes().take(1024).collect::<Vec<_>>();
-        for _ in 0..200 {
-            let to_write = &v[..thread_rng().gen_range(0..v.len())];
-            real.extend(to_write.iter().copied());
-            w.write_all(to_write).unwrap();
-        }
-        let result = w.finish().unwrap();
-        let mut r = read::GzDecoder::new(&result[..]);
-        let mut v = Vec::new();
-        r.read_to_end(&mut v).unwrap();
-        assert_eq!(v, real);
-    }
-
-    #[test]
-    fn roundtrip_big2() {
-        let v = crate::random_bytes().take(1024 * 1024).collect::<Vec<_>>();
-        let mut r = read::GzDecoder::new(read::GzEncoder::new(&v[..], Compression::default()));
-        let mut res = Vec::new();
-        r.read_to_end(&mut res).unwrap();
-        assert_eq!(res, v);
-    }
-
-    // A Rust implementation of CRC that closely matches the C code in RFC1952.
-    // Only use this to create CRCs for tests.
-    struct Rfc1952Crc {
-        /* Table of CRCs of all 8-bit messages. */
-        crc_table: [u32; 256],
-    }
-
-    impl Rfc1952Crc {
-        fn new() -> Self {
-            let mut crc = Rfc1952Crc {
-                crc_table: [0; 256],
-            };
-            /* Make the table for a fast CRC. */
-            for n in 0usize..256 {
-                let mut c = n as u32;
-                for _k in 0..8 {
-                    if c & 1 != 0 {
-                        c = 0xedb88320 ^ (c >> 1);
-                    } else {
-                        c = c >> 1;
-                    }
-                }
-                crc.crc_table[n] = c;
-            }
-            crc
-        }
-
-        /*
-         Update a running crc with the bytes buf and return
-         the updated crc. The crc should be initialized to zero. Pre- and
-         post-conditioning (one's complement) is performed within this
-         function so it shouldn't be done by the caller.
-        */
-        fn update_crc(&self, crc: u32, buf: &[u8]) -> u32 {
-            let mut c = crc ^ 0xffffffff;
-
-            for b in buf {
-                c = self.crc_table[(c as u8 ^ *b) as usize] ^ (c >> 8);
-            }
-            c ^ 0xffffffff
-        }
-
-        /* Return the CRC of the bytes buf. */
-        fn crc(&self, buf: &[u8]) -> u32 {
-            self.update_crc(0, buf)
-        }
-    }
-
-    #[test]
-    fn roundtrip_header() {
-        let mut header = GzBuilder::new()
-            .mtime(1234)
-            .operating_system(57)
-            .filename("filename")
-            .comment("comment")
-            .into_header(Compression::fast());
-
-        // Add a CRC to the header
-        header[3] = header[3] ^ super::FHCRC;
-        let rfc1952_crc = Rfc1952Crc::new();
-        let crc32 = rfc1952_crc.crc(&header);
-        let crc16 = crc32 as u16;
-        header.extend(&crc16.to_le_bytes());
-
-        let mut parser = GzHeaderParser::new();
-        parser.parse(&mut header.as_slice()).unwrap();
-        let actual = parser.header().unwrap();
-        assert_eq!(
-            actual,
-            &GzHeader {
-                extra: None,
-                filename: Some("filename".as_bytes().to_vec()),
-                comment: Some("comment".as_bytes().to_vec()),
-                operating_system: 57,
-                mtime: 1234
-            }
-        )
-    }
-
-    #[test]
-    fn fields() {
-        let r = vec![0, 2, 4, 6];
-        let e = GzBuilder::new()
-            .filename("foo.rs")
-            .comment("bar")
-            .extra(vec![0, 1, 2, 3])
-            .read(&r[..], Compression::default());
-        let mut d = read::GzDecoder::new(e);
-        assert_eq!(d.header().unwrap().filename(), Some(&b"foo.rs"[..]));
-        assert_eq!(d.header().unwrap().comment(), Some(&b"bar"[..]));
-        assert_eq!(d.header().unwrap().extra(), Some(&b"\x00\x01\x02\x03"[..]));
-        let mut res = Vec::new();
-        d.read_to_end(&mut res).unwrap();
-        assert_eq!(res, vec![0, 2, 4, 6]);
-    }
-
-    #[test]
-    fn keep_reading_after_end() {
-        let mut e = write::GzEncoder::new(Vec::new(), Compression::default());
-        e.write_all(b"foo bar baz").unwrap();
-        let inner = e.finish().unwrap();
-        let mut d = read::GzDecoder::new(&inner[..]);
-        let mut s = String::new();
-        d.read_to_string(&mut s).unwrap();
-        assert_eq!(s, "foo bar baz");
-        d.read_to_string(&mut s).unwrap();
-        assert_eq!(s, "foo bar baz");
-    }
-
-    #[test]
-    fn qc_reader() {
-        ::quickcheck::quickcheck(test as fn(_) -> _);
-
-        fn test(v: Vec<u8>) -> bool {
-            let r = read::GzEncoder::new(&v[..], Compression::default());
-            let mut r = read::GzDecoder::new(r);
-            let mut v2 = Vec::new();
-            r.read_to_end(&mut v2).unwrap();
-            v == v2
-        }
-    }
-
-    #[test]
-    fn flush_after_write() {
-        let mut f = write::GzEncoder::new(Vec::new(), Compression::default());
-        write!(f, "Hello world").unwrap();
-        f.flush().unwrap();
-    }
-}