buni-rs 1.1.1

use crate::deserialize::deserialize;
use crate::error::Result;
use crate::DeserializeError;
use nom::{Finish};
use serde_core::Deserialize;

#[cfg(feature = "iter")]
mod iterators;
mod deserialize;
mod sequence_deserializer;
mod map_deserializer;
mod enum_deserializer;
mod util;

pub use deserialize::Deserializer;

pub fn from_str<'a, T: Deserialize<'a>>(input: &str) -> Result<T, DeserializeError<&str>> {
    Ok(T::deserialize(&mut Deserializer::new(deserialize(input).finish()?.1.into_iter()))?)
}

#[test]
fn test_map() {
    use alloc::collections::BTreeMap;
    use alloc::string::ToString;
    use alloc::string::String;
    let mut expected = BTreeMap::new();
    expected.insert("a".to_string(), 1);
    expected.insert("b".to_string(), 2);

    assert_eq!(
        from_str::<BTreeMap<String, i32>>(r#"(a(1),b(2))"#).unwrap(),
        expected
    );
}

#[test]
fn test_struct() {
    use serde::Deserialize;
    use alloc::vec::Vec;
    use alloc::string::String;
    use alloc::vec;
    use alloc::boxed::Box;

    #[derive(Deserialize, Debug, PartialEq)]
    struct Test {
        int: u32,
        seq: Vec<String>,
        nested: Option<Box<Self>>
    }

    let expected = Test {
        int: 1,
        seq: vec!["a".into(), "b".into()],
        nested: Some(Box::new(Test {
            int: 50,
            seq: vec!["c".into(), "d".into()],
            nested: None,
        })),
    };

    assert_eq!(from_str::<Test>(r#"(
            int(
                1
            )
            seq(
                a,b
            )
            nested(
                int(50),
                seq(c,d),
                nested(null)
            )
        )"#).unwrap(), expected);
}

#[test]
fn test_enum() {
    use serde::Deserialize;
    #[derive(Deserialize)]
    #[derive(Debug)]
    #[derive(PartialEq)]
    enum E {
        Unit,
        Newtype(u32),
        Tuple(u32, u32),
        Struct { a: u32, b: u32 },
    }

    let expected = E::Unit;
    assert_eq!(from_str::<E>(r#"Unit"#).unwrap(), expected);

    let expected = E::Newtype(1);
    assert_eq!(from_str::<E>(r#"Newtype(1)"#).unwrap(), expected);

    let expected = E::Tuple(1, 2);
    assert_eq!(from_str::<E>(r#"Tuple(1,2)"#).unwrap(), expected);

    let expected = E::Struct { a: 1, b: 5 };
    assert_eq!(from_str::<E>(r#"Struct(a(1),b(5))"#).unwrap(), expected);
}

#[cfg(feature = "iter")]
use crate::deserialize::adapter::iterators::{DynIndexTracker, DynIter, IterAdapter, IterClone};

#[cfg(feature = "iter")]
use alloc::boxed::Box;

#[cfg(feature = "iter")]
pub fn from_iter<'a, T: Deserialize<'a>, I: IterClone<'a, char> + 'a>(iter: I) -> Result<T, DeserializeError<IterAdapter<'a, char>>> {
    Ok(T::deserialize(&mut Deserializer::new(deserialize(
        IterAdapter {
            inner: DynIndexTracker {
                length: iter.dyn_clone().count(),
                inner: DynIter {
                    inner: Box::new(iter),
                }.enumerate(),
                index: 0,
            },
        }
    ).finish()?.1.into_iter()))?)
}

#[test]
fn test_map_iter() {
    use alloc::collections::BTreeMap;
    use alloc::string::ToString;
    use alloc::string::String;
    use nom::Input;

    let mut expected = BTreeMap::new();
    expected.insert("a".to_string(), 1);
    expected.insert("b".to_string(), 2);

    assert_eq!(
        from_iter::<BTreeMap<String, i32>, _>(r#"(a(1),b(2))"#.iter_elements()).unwrap(),
        expected
    );
}

#[test]
fn test_struct_iter() {
    use serde::Deserialize;
    use alloc::vec::Vec;
    use alloc::string::String;
    use alloc::vec;
    use alloc::boxed::Box;
    use nom::Input;

    #[derive(Deserialize, Debug, PartialEq)]
    struct Test {
        int: u32,
        seq: Vec<String>,
        nested: Option<Box<Self>>
    }

    let expected = Test {
        int: 1,
        seq: vec!["a".into(), "b".into()],
        nested: Some(Box::new(Test {
            int: 50,
            seq: vec!["c".into(), "d".into()],
            nested: None,
        })),
    };

    assert_eq!(from_iter::<Test, _>(r#"(
            int(
                1
            )
            seq(
                a,b
            )
            nested(
                int(50),
                seq(c,d),
                nested(null)
            )
        )"#.iter_elements()).unwrap(), expected);
}

#[test]
fn test_enum_iter() {
    use serde::Deserialize;
    use nom::Input;

    #[derive(Deserialize)]
    #[derive(Debug)]
    #[derive(PartialEq)]
    enum E {
        Unit,
        Newtype(u32),
        Tuple(u32, u32),
        Struct { a: u32, b: u32 },
    }

    let expected = E::Unit;
    assert_eq!(from_iter::<E, _>(r#"Unit"#.iter_elements()).unwrap(), expected);

    let expected = E::Newtype(1);
    assert_eq!(from_iter::<E, _>(r#"Newtype(1)"#.iter_elements()).unwrap(), expected);

    let expected = E::Tuple(1, 2);
    assert_eq!(from_iter::<E, _>(r#"Tuple(1,2)"#.iter_elements()).unwrap(), expected);

    let expected = E::Struct { a: 1, b: 5 };
    assert_eq!(from_iter::<E, _>(r#"Struct(a(1),b(5))"#.iter_elements()).unwrap(), expected);
}