fosk 0.1.3

In-memory SQL-like query engine and lightweight data store for testing and prototyping.
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

use crate::parser::{ast::Literal, ParseError, QueryParser, WordComparer};

pub struct StringParser;

impl StringParser {
    pub fn is_string_delimiter(parser: &QueryParser) -> bool {
        parser.current() == '"' || parser.current() == '\''
    }

    pub fn parse(parser: &mut QueryParser) -> Result<Literal, ParseError> {
        let mut pivot = parser.position;

        if !StringParser::is_string_delimiter(parser) {
            return Err(ParseError::new("Invalid string value", pivot, parser));
        }

        let delimiter = parser.current();
        parser.next();
        pivot = parser.position;

        while !parser.eof() && parser.current() != delimiter {
            if WordComparer::is_current_break_line(parser) {
                return Err(ParseError::new("Invalid string", pivot, parser));
            }

            parser.next();
        }
        if parser.eof() {
            return Err(ParseError::new("Invalid string", pivot, parser));
        }

        let text = parser.text_from_pivot(pivot);
        parser.next();

        Ok(Literal::String(text))
    }
}

#[cfg(test)]
pub mod tests {
    use crate::parser::{ast::{Literal, StringParser}, QueryParser};

    #[test]
    pub fn test_string_parser() {
        let text = "\"identifier\"";

        let mut parser = QueryParser::new(text);

        let result = StringParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::String(result) => assert_eq!(result, "identifier"),
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_string_parser_single_quote() {
        let text = "'identifier'";

        let mut parser = QueryParser::new(text);

        let result = StringParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::String(result) => assert_eq!(result, "identifier"),
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_string_parser_tab() {
        let text = "\"start\tend\"";

        let mut parser = QueryParser::new(text);

        let result = StringParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                Literal::String(result) => assert_eq!(result, "start\tend"),
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_string_parser_break_line() {
        let text = "\"lets\r\nbreak line\"";

        let mut parser = QueryParser::new(text);

        let result = StringParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "lets\r");
                assert_eq!(err.start, 1);
                assert_eq!(err.end, 5);
            },
        }
    }
}