muesli 0.1.0

healthy implementation of PHP's serialization and session formats in Rust
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
130
131
132
133
134
135
136
137
138
139
140
141

use winnow::{
    binary::length_take,
    combinator::{opt, terminated},
    token::take_while,
    Parser, Result,
};

pub(crate) fn unsigned_integer<'s>(input: &mut &'s [u8]) -> Result<&'s [u8]> {
    take_while(1.., b'0'..=b'9').parse_next(input)
}

pub(crate) fn signed_integer<'s>(input: &mut &'s [u8]) -> Result<&'s [u8]> {
    (opt(b'-'), unsigned_integer).take().parse_next(input)
}

pub(crate) fn float<'s>(input: &mut &'s [u8]) -> Result<&'s [u8]> {
    (signed_integer, opt((b'.', unsigned_integer)))
        .take()
        .parse_next(input)
}

pub(crate) fn size(input: &mut &[u8]) -> Result<usize> {
    unsigned_integer.parse_to().parse_next(input)
}

pub(crate) fn sized_string<'s>(input: &mut &'s [u8]) -> Result<&'s [u8]> {
    terminated(length_take(terminated(size, b":\"")), b'"').parse_next(input)
}

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

    #[test]
    fn parse_unsigned_integer() {
        let cases = [
            (b"0".as_slice(), Some((b"".as_slice(), b"0".as_slice()))),
            (b"123".as_slice(), Some((b"".as_slice(), b"123".as_slice()))),
            (
                b"745a".as_slice(),
                Some((b"a".as_slice(), b"745".as_slice())),
            ),
            (
                b"592.6".as_slice(),
                Some((b".6".as_slice(), b"592".as_slice())),
            ),
            (b"".as_slice(), None),
            (b"a".as_slice(), None),
            (b"-123".as_slice(), None),
        ];

        run_cases(unsigned_integer, &cases);
    }

    #[test]
    fn parse_signed_integer() {
        let cases = [
            (b"-0".as_slice(), Some((b"".as_slice(), b"-0".as_slice()))),
            (b"123".as_slice(), Some((b"".as_slice(), b"123".as_slice()))),
            (
                b"745a".as_slice(),
                Some((b"a".as_slice(), b"745".as_slice())),
            ),
            (
                b"592.6".as_slice(),
                Some((b".6".as_slice(), b"592".as_slice())),
            ),
            (
                b"-592.6".as_slice(),
                Some((b".6".as_slice(), b"-592".as_slice())),
            ),
            (b"".as_slice(), None),
            (b"a".as_slice(), None),
        ];

        run_cases(signed_integer, &cases);
    }

    #[test]
    fn parse_float() {
        let cases = [
            (b"-0".as_slice(), Some((b"".as_slice(), b"-0".as_slice()))),
            (b"123".as_slice(), Some((b"".as_slice(), b"123".as_slice()))),
            (
                b"745a".as_slice(),
                Some((b"a".as_slice(), b"745".as_slice())),
            ),
            (
                b"592.6".as_slice(),
                Some((b"".as_slice(), b"592.6".as_slice())),
            ),
            (
                b"-592.6".as_slice(),
                Some((b"".as_slice(), b"-592.6".as_slice())),
            ),
            (b"".as_slice(), None),
            (b"a".as_slice(), None),
        ];

        run_cases(float, &cases);
    }

    #[test]
    fn parse_size() {
        let cases = [
            (b"1".as_slice(), Some((b"".as_slice(), 1))),
            (
                b"1234567890".as_slice(),
                Some((b"".as_slice(), 1_234_567_890)),
            ),
            (b"323;".as_slice(), Some((b";".as_slice(), 323))),
            (b"".as_slice(), None),
            (b"a".as_slice(), None),
            (b"a:\"asd\"".as_slice(), None),
            (b"-2:\"asd\"".as_slice(), None),
        ];

        run_cases(size, &cases);
    }

    #[test]
    fn parse_sized_string() {
        let cases = [
            (
                b"1:\"a\"".as_slice(),
                Some((b"".as_slice(), b"a".as_slice())),
            ),
            (
                b"10:\"1234567890\"".as_slice(),
                Some((b"".as_slice(), b"1234567890".as_slice())),
            ),
            (b"".as_slice(), None),
            (b"a".as_slice(), None),
            (b"a:\"asd\"".as_slice(), None),
            (b"-2:\"asd\"".as_slice(), None),
        ];

        run_cases(sized_string, &cases);
    }
}