irk 0.1.1

A lil (wip) IRC protocol library
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

pub mod error;
pub mod proto;

pub use error::{Error, Result};
pub use proto::{ser::Serializer, Command};

#[derive(Debug, Default, PartialEq, Eq)]
pub struct Message<'a> {
    pub source: Option<&'a str>,
    pub command: &'a str,
    pub parameters: Vec<&'a str>,
}

impl std::fmt::Display for Message<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(src) = self.source {
            write!(f, ":{src} ")?;
        }

        write!(f, "{}", self.command)?;

        if let Some((last, rest)) = self.parameters.split_last() {
            rest.iter().try_for_each(|v| write!(f, " {v}"))?;
            write!(f, " :{last}")?;
        }

        Ok(())
    }
}

struct Lexer<'a> {
    input: &'a str,
}

impl<'a> Lexer<'a> {
    fn new(input: &'a str) -> Self {
        Self { input }
    }

    fn current(&self) -> Option<char> {
        self.input.chars().next()
    }

    fn read_part(&mut self) -> &'a str {
        let (part, input) = self
            .input
            .split_once(' ')
            .unwrap_or((self.input, &self.input[..0]));
        self.input = input.trim_start_matches(' ');
        part
    }

    fn parse(&mut self) -> Message<'a> {
        let source = match self.current() {
            Some(':') => {
                self.input = &self.input[1..];
                Some(self.read_part())
            }
            _ => None,
        };

        let command = self.read_part();

        let mut parameters = Vec::new();
        loop {
            match self.current() {
                Some(':') => break parameters.push(&self.input[1..]),
                Some(_) => parameters.push(self.read_part()),
                None => break,
            }
        }

        Message {
            source,
            command,
            parameters,
        }
    }
}

impl<'a> From<&'a str> for Message<'a> {
    fn from(value: &'a str) -> Self {
        Lexer::new(value).parse()
    }
}

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

    macro_rules! test_parse {
        ($name:ident; $($in:literal => $out:expr),*) => {
            #[test]
            fn $name() {
                $(assert_eq!($in.try_into(), $out);)*
            }
        };
    }

    test_parse! {
        parse_rfc;
        ":irc.example.com CAP * LIST :" => Ok(Message {
            source: Some("irc.example.com"),
            command: "CAP",
            parameters: vec!["*", "LIST", ""],
        }),
        "CAP * LS :multi-prefix sasl" => Ok(Message {
            source: None,
            command: "CAP",
            parameters: vec!["*", "LS", "multi-prefix sasl"],
        }),
        "CAP REQ :sasl message-tags foo" => Ok(Message {
            source: None,
            command: "CAP",
            parameters: vec!["REQ", "sasl message-tags foo"],
        })
    }
}