helpers.rs

use serde::ser::{Impossible, Serialize, Serializer, Error as SerError};
use error::Error;


/// Check if a value would be "wrapped" when serialized as XML. 
///
/// As a rule of thumb, if something **isn't** wrapped then the XML serialized
/// version would look similar to what you get from `Display`. Wrapped things 
/// typically look like `<foo>...</foo>`.
pub fn is_wrapped<S>(thing: &S) -> bool
where
    S: Serialize + ?Sized,
{
    let mut is_wrapped = false;

    thing.serialize(WrapSafeDetector{ is_wrapped: &mut is_wrapped }).ok();

    is_wrapped
}

#[derive(Debug)]
struct WrapSafeDetector<'a> {
    is_wrapped: &'a mut bool,
}

#[allow(unused_variables)]
impl<'a> Serializer for WrapSafeDetector<'a> {
    type Ok = ();
    type Error = Error;

    type SerializeSeq = Impossible<Self::Ok, Self::Error>;
    type SerializeTuple = Impossible<Self::Ok, Self::Error>;
    type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
    type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
    type SerializeMap = Impossible<Self::Ok, Self::Error>;
    type SerializeStruct = Impossible<Self::Ok, Self::Error>;
    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
        value.serialize(self)
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = false;
        Ok(())
    }

    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = true;
        Ok(())
    }

    fn serialize_unit_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = true;
        Ok(())
    }

    fn serialize_newtype_struct<T: ?Sized + Serialize>(
        self,
        name: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = true;
        Ok(())
    }

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        *self.is_wrapped = true;
        Ok(())
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        // FIXME: Is a sequence of sequences okay here?
        *self.is_wrapped = false;
        Err(Error::custom("Ignore me...".to_string()))
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        // FIXME: I think a tuple counts as a "primitive"... doesn't it?
        *self.is_wrapped = false;
        Err(Error::custom("Ignore me...".to_string()))
    }

    fn serialize_tuple_struct(
        self,
        name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        *self.is_wrapped = true;
        Err(Error::custom("Ignore me...".to_string()))
    }

    fn serialize_tuple_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        *self.is_wrapped = true;
        Err(Error::custom("Ignore me...".to_string()))
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        *self.is_wrapped = true;
        Err(Error::custom("Ignore me...".to_string()))
    }

    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
        *self.is_wrapped = true;
        Err(Error::custom("Ignore me...".to_string()))
    }

    fn serialize_struct_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        *self.is_wrapped = true;
        Err(Error::custom("Ignore me...".to_string()))
    }
}


#[cfg(test)]
#[allow(dead_code)]
mod tests {
    use super::*;

    macro_rules! prim_check {
        ($name:ident, $ty:path) => {
            #[test]
            fn $name() {
                let v: $ty = 0 as $ty;
                assert!(!is_wrapped(&v));
            }
        }
    }

    prim_check!(check_u8_is_primitive, u8);
    prim_check!(check_i8_is_primitive, i8);
    prim_check!(check_u16_is_primitive, u16);
    prim_check!(check_i16_is_primitive, i16);
    prim_check!(check_u32_is_primitive, u32);
    prim_check!(check_i32_is_primitive, i32);
    prim_check!(check_u64_is_primitive, u64);
    prim_check!(check_i64_is_primitive, i64);
    prim_check!(check_f32_is_primitive, f32);
    prim_check!(check_f64_is_primitive, f64);

    #[derive(Default, Serialize)]
    struct UnitStruct;

    #[derive(Default, Serialize)]
    struct Newtype(u32);

    #[derive(Default, Serialize)]
    struct TupleStruct(u32, bool);

    #[derive(Default, Serialize)]
    struct NormalStruct {
        x: u32,
        y: u32,
    }

    macro_rules! struct_check {
        ($name:ident, $ty:path) => {
            #[test]
            fn $name() {
                let value: $ty = Default::default();

                assert!(is_wrapped(&value));
            }
        }
    }

    struct_check!(check_unit_struct, UnitStruct);
    struct_check!(check_newtype_struct, Newtype);
    struct_check!(check_tuple_struct, TupleStruct);
    struct_check!(check_normal_struct, NormalStruct);

    #[derive(Serialize)]
    enum BoringEnum {
        A, 
        B,
    }

    #[derive(Serialize)]
    enum BasicRustEnum {
        A(u32), 
        B(f64),
    }

    #[derive(Serialize)]
    enum StructEnum {
        A{ x: u32, y: u32 },
    }

    macro_rules! enum_check {
        ($name:ident, $init:expr) => {
            #[test]
            fn $name() {
                let value = $init;
                assert!(is_wrapped(&value));
            }
        }
    }

    enum_check!(check_c_style_enum, BoringEnum::A);
    enum_check!(check_basic_rust_style_enum, BasicRustEnum::A(5));
    enum_check!(check_struct_enum, StructEnum::A{x: 1, y: 2});

    #[test]
    fn check_unit_is_primitive() {
        assert!(!is_wrapped(&()));
    }

    #[test]
    fn check_some_of_primitive_is_primitive() {
        assert!(!is_wrapped(&Some(42)));
    }

    #[test]
    fn check_none_is_primitive() {
        let value: Option<u32> = None;
        assert!(!is_wrapped(&value));
    }

    #[test]
    fn check_vec_of_primitives_isnt_wrapped() {
        let value = vec![1_u32, 2, 3, 4];
        assert!(!is_wrapped(&value));
    }
}