repl_framework 0.3.0

A crate to easily create simple repls
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

use std::{mem, ops};

#[derive(Clone, Copy)]
pub(crate) struct FnPtr<T>(pub fn(&mut T, Vec<String>));

impl<T> std::fmt::Debug for FnPtr<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Pointer::fmt(&(self.0 as usize as *const ()), f)
    }
}

impl<T> ops::Deref for FnPtr<T> {
    type Target = fn(&mut T, Vec<String>);

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub fn parse(input: String) -> Vec<String> {
    #[derive(Debug, Clone, Default)]
    struct ParserState {
        in_literal: bool,
        last_char: Option<char>,
        last_quote: Option<char>,
        parsed_args: Vec<String>,
        current_arg: String,
    }
    let mut result = input
        .chars()
        .fold(ParserState::default(), |mut state, chr| {
            match state.in_literal {
                true => {
                    if state.last_char != Some('\\') && state.last_quote == Some(chr) {
                        state.in_literal = false;
                        state.last_quote = None;
                        if !state.current_arg.is_empty() {
                            state.parsed_args.push(mem::take(&mut state.current_arg));
                        }
                    } else if state.last_char == Some('\\') {
                        state.current_arg.push(match chr {
                            't' => '\t',
                            'n' => '\n',
                            '"' => '"',
                            '\'' => '\'',
                            '\\' => '\\',
                            _ => panic!("unknown escape character {:?} in input", chr),
                        })
                    } else if chr != '\\' {
                        state.current_arg.push(chr)
                    }
                }
                false => {
                    if chr == ' ' {
                        if !state.current_arg.is_empty() {
                            state.parsed_args.push(mem::take(&mut state.current_arg));
                        }
                    } else if state.last_char == Some('\\') {
                        state.current_arg.push(if chr == 't' {
                            '\t'
                        } else if chr == 'n' {
                            '\n'
                        } else if chr == '"' {
                            '"'
                        } else if chr == '\'' {
                            '\''
                        } else if chr == '\\' {
                            '\\'
                        } else {
                            panic!("unknown escape character {:?} in input", chr);
                        })
                    } else if (chr == '"' || chr == '\'') && state.last_char != Some('\\') {
                        state.in_literal = true;
                        state.last_quote = Some(chr);
                        if !state.current_arg.is_empty() {
                            state.parsed_args.push(mem::take(&mut state.current_arg));
                        }
                    } else if chr != '\\' {
                        state.current_arg.push(chr)
                    } else {
                        state.current_arg.push(chr);
                    }
                }
            }
            state.last_char = Some(chr);
            state
        });
    result.parsed_args.push(mem::take(&mut result.current_arg));
    if result.in_literal {
        panic!("non matching quote characters found!");
    }
    result.parsed_args
}

#[cfg(test)]
mod tests {
    use super::parse;
    use std::panic::catch_unwind;
    #[test]
    fn test_parse() {
        assert_eq!(
            parse(String::from(r#""hello world" world"#)),
            vec!["hello world", "world"]
        );
        assert_eq!(
            parse(String::from(r#"hello world"#)),
            vec!["hello", "world"]
        );
        assert_eq!(
            parse(String::from(r#""hello\"" world"#)),
            vec!["hello\"", "world"]
        );
        assert!(catch_unwind(|| dbg!(parse(String::from(r#"\hello"#)))).is_err());
    }
}