rolodex 0.1.2

A Forgiving VCard implementation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use nom::{error::VerboseError, IResult};

use std::fmt;

use crate::property::{ parse_end, parse_begin };
use crate::{ Parse, ParseError, Property };

#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VCard<'a>(pub Vec<Property<'a>>);

impl<'a> fmt::Display for VCard<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let data = self.0.iter()
            .map(|x|format!("{}", x))
            .collect::<Vec<String>>()
            .join("\r\n");
        write!(f, "BEGIN:VCARD\r\n{}\r\nEND:VCARD", data)?;
        Ok(())
    }
}

impl<'a> VCard<'a> {
    pub fn iter(&self) -> impl Iterator<Item = &Property<'a>> {
        self.0.iter()
    }

    pub fn parse(input: &'a str) -> std::result::Result<VCard<'a>, nom::Err<ParseError>> {
        Ok(Parse::parse(input)?.1)
    }
}

impl<'a> Parse<'a> for VCard<'a> {
    fn parse(mut input: &'a str) -> IResult<&'a str, Self, ParseError> {
        use nom::bytes::complete::tag;
        let mut properties = vec![];
        match parse_begin(input) {
            Ok((remains, _)) => input = remains,
            Err(nom::Err::Incomplete(size)) => return Err(nom::Err::Incomplete(size)),
            Err(nom::Err::Error(err)) => return Err(nom::Err::Error(err.into())),
            Err(nom::Err::Failure(err)) => return Err(nom::Err::Failure(err.into()))
        }
        while let Ok((remaining, prop)) = Parse::parse(input) {
            properties.push(prop);
            match tag::<&str, &str, VerboseError<&str>>("\n")(remaining) {
                Ok((remaining, _)) => input = remaining,
                Err(_) => input = remaining,
            }
        }
        match parse_end(input) {
            Ok((remains, _)) => input = remains,
            Err(nom::Err::Incomplete(size)) => return Err(nom::Err::Incomplete(size)),
            Err(nom::Err::Error(err)) => return Err(nom::Err::Error(err.into())),
            Err(nom::Err::Failure(err)) => return Err(nom::Err::Failure(err.into()))
        }
        Ok((input, VCard(properties)))
    }
}