lib-resp 0.1.1

A high-performance, nom-based RESP implementation for 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

use super::Value;
use std::str::FromStr;
use nom::{crlf, digit, not_line_ending};

/// Core parser implementation.
pub struct Parser;

impl Parser {
    /// Parses RESP from a byte buffer.
    pub fn parse(data: &[u8]) -> Result<(&[u8], Value), ::nom::Err<&[u8]>> {
        named!(
            read_line<&str>,
            do_parse!(line: map_res!(not_line_ending, ::std::str::from_utf8) >> crlf >> (line))
        );

        named!(
            int<i64>,
            do_parse!(
                neg: opt!(tag!("-"))
                    >> value: map_res!(map_res!(digit, ::std::str::from_utf8), i64::from_str)
                    >> (if neg == None { value } else { -value })
            )
        );

        named!(
            parse_int<Value>,
            preceded!(
                tag!(":"),
                do_parse!(datum: int >> crlf >> (Value::Int(datum)))
            )
        );

        named!(
            parse_str<Value>,
            preceded!(
                tag!("+"),
                do_parse!(datum: read_line >> (Value::str(datum)))
            )
        );

        named!(
            parse_err<Value>,
            preceded!(
                tag!("-"),
                do_parse!(datum: read_line >> (Value::err(datum)))
            )
        );

        named!(
            parse_bstr<Value>,
            preceded!(
                tag!("$"),
                do_parse!(
                    len: int >> crlf >> datum: cond_with_error!(len > -1, take_str!(len))
                        >> cond_with_error!(len > -1, crlf)
                        >> (Value::b_str(datum))
                )
            )
        );

        named!(
            parse_array<Value>,
            preceded!(
                tag!("*"),
                do_parse!(
                    len: int >> crlf
                        >> data: cond_with_error!(len > -1, count!(parse_resp, len as usize))
                        >> (Value::Array(data))
                )
            )
        );

        named!(
            parse_resp<Value>,
            alt!(parse_int | parse_str | parse_err | parse_bstr | parse_array)
        );

        parse_resp(data)
    }

    /// Parses a RESP encoded string.
    ///
    /// # Examples
    ///
    /// ```
    /// # use lib_resp::Parser;
    /// let age = Parser::parse_str(":-3").unwrap();
    ///
    /// println!("{:?}", age);
    /// ```
    pub fn parse_str(resp: &str) -> Result<Option<Value>, ()> {
        match Parser::parse(resp.as_bytes()) {
            Ok((_i, o)) => Ok(Some(o)),
            Err(e) => {
                if e.is_incomplete() {
                    Ok(None)
                } else {
                    Err(())
                }
            }
        }
    }
}