eight 1.0.0-alpha.2

Modular asynchronous embedded key-value database
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

use std::collections::HashMap;

use crate::embedded::{
    language::{lexer::Lexer, parser::CallType, parser::Parser, token::Token},
    messaging::Request,
};

#[test]
fn test_execute_lexer() {
    let mut lex = Lexer::new(
        "this is lexer # comment; \n aftercomment ; \"stringwithoutspace\"; \"string \\\"with space\";".to_string()
    );
    lex.execute();

    assert_eq!(
        lex.collect(),
        vec![
            vec![
                Token {
                    value: "this".to_string(),
                    line: 1,
                    column: 4,
                },
                Token {
                    value: "is".to_string(),
                    line: 1,
                    column: 7,
                },
                Token {
                    value: "lexer".to_string(),
                    line: 1,
                    column: 13,
                },
                Token {
                    value: "aftercomment".to_string(),
                    line: 2,
                    column: 13,
                },
            ],
            vec![Token {
                value: "stringwithoutspace".to_string(),
                line: 2,
                column: 35,
            }],
            vec![Token {
                value: "string \"with space".to_string(),
                line: 2,
                column: 58,
            },]
        ]
    );
}

#[test]
fn test_execute_parser() {
    let mut env = HashMap::new();

    let a = "A".to_string();
    let b = "B".to_string();
    let c = 1;

    env.insert("varA".to_string(), a.clone());
    env.insert("varB".to_string(), b.clone());
    env.insert("varC".to_string(), c.to_string());
    let mut parser = Parser::new(env);

    assert_eq!(
        parser.execute(tokenize("set $varA $varB")).unwrap(),
        CallType::Await(Request::Set(a.clone(), b.clone()))
    );

    assert_eq!(
        parser.execute(tokenize("get $varA")).unwrap(),
        CallType::Await(Request::Get(a.clone()))
    );

    assert_eq!(
        parser.execute(tokenize("delete $varA")).unwrap(),
        CallType::Await(Request::Delete(a.clone()))
    );

    assert_eq!(
        parser.execute(tokenize("incr $varA $varC")).unwrap(),
        CallType::Await(Request::Increment(a.clone(), c))
    );

    assert_eq!(
        parser.execute(tokenize("decr $varA $varC")).unwrap(),
        CallType::Await(Request::Decrement(a.clone(), c))
    );

    assert_eq!(
        parser.execute(tokenize("search $varA")).unwrap(),
        CallType::Await(Request::Search(a.clone()))
    );

    assert_eq!(
        parser.execute(tokenize("flush")).unwrap(),
        CallType::Await(Request::Flush)
    );

    assert_eq!(
        parser.execute(tokenize("downgrade")).unwrap(),
        CallType::Await(Request::DowngradePermission)
    );

    assert_eq!(
        parser.execute(tokenize("set? $varA $varB")).unwrap(),
        CallType::Spawn(Request::Set(a.clone(), b.clone()))
    );
}

// starting here, internal functions for testing only
fn tokenize(input: &str) -> Vec<Token> {
    input
        .split(' ')
        .map(|t| Token {
            value: t.to_string(),
            line: 1,
            column: 1,
        })
        .collect()
}