fapt 0.1.0

Faux' apt package manager for Debian
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use failure::bail;
use failure::format_err;
use failure::Error;
use nom::types::CompleteStr;
use nom::Err;

/// A user identity, e.g. `John Smith <john@smi.th>`
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Identity {
    pub name: String,
    pub email: String,
}

named!(ident<CompleteStr, Result<Identity, Error>>,
    do_parse!(
        name: take_until_and_consume_s!(" <") >>
        email: take_until_and_consume_s!(">") >>
        ( process_escapes(name.0.trim()).map(|name|
            Identity {
                name: name.to_string(),
                email: email.0.to_string(),
            })
        )
    )
);

named!(parse<CompleteStr, Vec<Result<Identity, Error>>>,
    ws!(
        terminated!(
            separated_list!(
                complete!(tag!(",")),
                complete!(ident)
            ),
            opt!(complete!(tag!(",")))
        )
    )
);

pub fn read(from: &str) -> Result<Vec<Identity>, Error> {
    match parse(CompleteStr(from)) {
        Ok((CompleteStr(""), vec)) => vec.into_iter().collect::<Result<Vec<Identity>, Error>>(),
        Ok((tailing, _)) => bail!(
            "parsing {:?} finished early, trailing garbage: {:?}",
            from,
            tailing
        ),
        Err(Err::Incomplete(_)) => unreachable!(),
        other => bail!("parsing {:?} failed: {:?}", from, other),
    }
}

fn process_escapes(from: &str) -> Result<String, Error> {
    let mut bytes = from.bytes();
    let mut result = Vec::with_capacity(bytes.len());
    loop {
        match bytes.next() {
            Some(c) if b'\\' == c => match bytes.next() {
                Some(c) if [b'\'', b'"'].contains(&c) => result.push(c),
                Some(c) if b'x' == c => result.push(parse_ascii_hex(
                    bytes
                        .next()
                        .ok_or_else(|| format_err!("\\x must be followed by a character"))?,
                    bytes
                        .next()
                        .ok_or_else(|| format_err!("\\xX must be followed"))?,
                )?),
                Some(c) => bail!("unsupported escape: {:?}", c),
                None => bail!("\\ at end of string"),
            },
            Some(c) => result.push(c),
            None => return Ok(String::from_utf8(result)?),
        }
    }
}

fn parse_ascii_hex(first: u8, second: u8) -> Result<u8, Error> {
    // Bit ugly, but at least it doesn't involve any code
    Ok(u8::from_str_radix(
        &String::from_utf8(vec![first, second])?,
        16,
    )?)
}

#[cfg(test)]
mod tests {
    #[test]
    fn backslash() {
        use super::process_escapes;
        assert_eq!("foo", &process_escapes("foo").unwrap());
        assert_eq!("fo'o", &process_escapes("fo\\'o").unwrap());
        assert_eq!("fo'", &process_escapes("fo\\'").unwrap());
        assert!(process_escapes("fo\\").is_err());
        assert!(process_escapes("fo\\a").is_err());

        assert_eq!("a", &process_escapes("\\x61").unwrap());
    }

    #[test]
    fn read() {
        use super::read;
        use super::Identity;

        assert_eq!(
            vec![
                Identity {
                    name: "foo".to_string(),
                    email: "bar".to_string(),
                },
                Identity {
                    name: "baz".to_string(),
                    email: "quux".to_string(),
                },
            ],
            read("foo <bar>, baz <quux>").unwrap()
        );
    }

    #[test]
    fn lazy() {
        use super::read;
        assert!(read("just@email.com").is_err());
    }

    #[test]
    fn trailing() {
        use super::read;
        assert_eq!(1, read("foo <bar>,").unwrap().len())
    }
}