Deleted vendor folder

1 files changed, 0 insertions, 400 deletions

diff --git a/vendor/log/src/serde.rs b/vendor/log/src/serde.rs
deleted file mode 100644
index 5012833..0000000
--- a/vendor/log/src/serde.rs
+++ /dev/null
@@ -1,400 +0,0 @@
-#![cfg(feature = "serde")]
-
-extern crate serde;
-use self::serde::de::{
-    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
-    Visitor,
-};
-use self::serde::ser::{Serialize, Serializer};
-
-use {Level, LevelFilter, LOG_LEVEL_NAMES};
-
-use std::fmt;
-use std::str::{self, FromStr};
-
-// The Deserialize impls are handwritten to be case insensitive using FromStr.
-
-impl Serialize for Level {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
-            Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
-            Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
-            Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
-            Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Level {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct LevelIdentifier;
-
-        impl<'de> Visitor<'de> for LevelIdentifier {
-            type Value = Level;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                // Case insensitive.
-                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
-            }
-
-            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = str::from_utf8(value)
-                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
-
-                self.visit_str(variant)
-            }
-
-            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = LOG_LEVEL_NAMES[1..]
-                    .get(v as usize)
-                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;
-
-                self.visit_str(variant)
-            }
-        }
-
-        impl<'de> DeserializeSeed<'de> for LevelIdentifier {
-            type Value = Level;
-
-            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                deserializer.deserialize_identifier(LevelIdentifier)
-            }
-        }
-
-        struct LevelEnum;
-
-        impl<'de> Visitor<'de> for LevelEnum {
-            type Value = Level;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level")
-            }
-
-            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                let (level, variant) = value.variant_seed(LevelIdentifier)?;
-                // Every variant is a unit variant.
-                variant.unit_variant()?;
-                Ok(level)
-            }
-        }
-
-        deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
-    }
-}
-
-impl Serialize for LevelFilter {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
-            LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
-            LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
-            LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
-            LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
-            LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for LevelFilter {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct LevelFilterIdentifier;
-
-        impl<'de> Visitor<'de> for LevelFilterIdentifier {
-            type Value = LevelFilter;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level filter")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                // Case insensitive.
-                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
-            }
-
-            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = str::from_utf8(value)
-                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
-
-                self.visit_str(variant)
-            }
-
-            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = LOG_LEVEL_NAMES
-                    .get(v as usize)
-                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;
-
-                self.visit_str(variant)
-            }
-        }
-
-        impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
-            type Value = LevelFilter;
-
-            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                deserializer.deserialize_identifier(LevelFilterIdentifier)
-            }
-        }
-
-        struct LevelFilterEnum;
-
-        impl<'de> Visitor<'de> for LevelFilterEnum {
-            type Value = LevelFilter;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level filter")
-            }
-
-            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
-                // Every variant is a unit variant.
-                variant.unit_variant()?;
-                Ok(level_filter)
-            }
-        }
-
-        deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    extern crate serde_test;
-    use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
-
-    use {Level, LevelFilter};
-
-    fn level_token(variant: &'static str) -> Token {
-        Token::UnitVariant {
-            name: "Level",
-            variant: variant,
-        }
-    }
-
-    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
-        [
-            Token::Enum { name: "Level" },
-            Token::Bytes(variant),
-            Token::Unit,
-        ]
-    }
-
-    fn level_variant_tokens(variant: u32) -> [Token; 3] {
-        [
-            Token::Enum { name: "Level" },
-            Token::U32(variant),
-            Token::Unit,
-        ]
-    }
-
-    fn level_filter_token(variant: &'static str) -> Token {
-        Token::UnitVariant {
-            name: "LevelFilter",
-            variant: variant,
-        }
-    }
-
-    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
-        [
-            Token::Enum {
-                name: "LevelFilter",
-            },
-            Token::Bytes(variant),
-            Token::Unit,
-        ]
-    }
-
-    fn level_filter_variant_tokens(variant: u32) -> [Token; 3] {
-        [
-            Token::Enum {
-                name: "LevelFilter",
-            },
-            Token::U32(variant),
-            Token::Unit,
-        ]
-    }
-
-    #[test]
-    fn test_level_ser_de() {
-        let cases = [
-            (Level::Error, [level_token("ERROR")]),
-            (Level::Warn, [level_token("WARN")]),
-            (Level::Info, [level_token("INFO")]),
-            (Level::Debug, [level_token("DEBUG")]),
-            (Level::Trace, [level_token("TRACE")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_case_insensitive() {
-        let cases = [
-            (Level::Error, [level_token("error")]),
-            (Level::Warn, [level_token("warn")]),
-            (Level::Info, [level_token("info")]),
-            (Level::Debug, [level_token("debug")]),
-            (Level::Trace, [level_token("trace")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_de_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_de_bytes() {
-        let cases = [
-            (Level::Error, level_bytes_tokens(b"ERROR")),
-            (Level::Warn, level_bytes_tokens(b"WARN")),
-            (Level::Info, level_bytes_tokens(b"INFO")),
-            (Level::Debug, level_bytes_tokens(b"DEBUG")),
-            (Level::Trace, level_bytes_tokens(b"TRACE")),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_de_variant_index() {
-        let cases = [
-            (Level::Error, level_variant_tokens(0)),
-            (Level::Warn, level_variant_tokens(1)),
-            (Level::Info, level_variant_tokens(2)),
-            (Level::Debug, level_variant_tokens(3)),
-            (Level::Trace, level_variant_tokens(4)),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_de_error() {
-        let msg = "unknown variant `errorx`, expected one of \
-                   `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
-        assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
-    }
-
-    #[test]
-    fn test_level_filter_ser_de() {
-        let cases = [
-            (LevelFilter::Off, [level_filter_token("OFF")]),
-            (LevelFilter::Error, [level_filter_token("ERROR")]),
-            (LevelFilter::Warn, [level_filter_token("WARN")]),
-            (LevelFilter::Info, [level_filter_token("INFO")]),
-            (LevelFilter::Debug, [level_filter_token("DEBUG")]),
-            (LevelFilter::Trace, [level_filter_token("TRACE")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_case_insensitive() {
-        let cases = [
-            (LevelFilter::Off, [level_filter_token("off")]),
-            (LevelFilter::Error, [level_filter_token("error")]),
-            (LevelFilter::Warn, [level_filter_token("warn")]),
-            (LevelFilter::Info, [level_filter_token("info")]),
-            (LevelFilter::Debug, [level_filter_token("debug")]),
-            (LevelFilter::Trace, [level_filter_token("trace")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_de_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_de_bytes() {
-        let cases = [
-            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
-            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
-            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
-            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
-            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
-            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_de_variant_index() {
-        let cases = [
-            (LevelFilter::Off, level_filter_variant_tokens(0)),
-            (LevelFilter::Error, level_filter_variant_tokens(1)),
-            (LevelFilter::Warn, level_filter_variant_tokens(2)),
-            (LevelFilter::Info, level_filter_variant_tokens(3)),
-            (LevelFilter::Debug, level_filter_variant_tokens(4)),
-            (LevelFilter::Trace, level_filter_variant_tokens(5)),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_de_error() {
-        let msg = "unknown variant `errorx`, expected one of \
-                   `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
-        assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
-    }
-}