Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 400 insertions, 0 deletions

diff --git a/vendor/log/src/serde.rs b/vendor/log/src/serde.rs
new file mode 100644
index 0000000..5012833
--- /dev/null
+++ b/vendor/log/src/serde.rs
@@ -0,0 +1,400 @@
+#![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);
+    }
+}