caprice 0.3.3

A REPL for Rust projects featuring an easy to use, zsh like autocomplete feature.
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

use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};

pub(crate) enum TokenType {
    Token(String),
    BackSpace,
    Continue(String),
    Tab(String),
    Exit,
    None,
}

#[derive(Debug)]
pub(crate) struct Scanner {
    buffer: String,
    pub(crate) enable_ctrl_c: bool,
}

impl Scanner {
    pub(crate) fn new() -> Self {
        Scanner {
            buffer: String::new(),
            enable_ctrl_c: true,
        }
    }

    pub(crate) fn scan(&mut self, input_event: Event) -> TokenType {
        match input_event {
            Event::Key(KeyEvent {
                code: KeyCode::Tab, ..
            }) => self.scan_tab(),
            Event::Key(KeyEvent {
                code: KeyCode::Enter,
                ..
            }) => self.scan_enter(),
            Event::Key(KeyEvent {
                code: KeyCode::Char('c'),
                modifiers: KeyModifiers::CONTROL,
            }) => self.scan_ctrl_c(),
            Event::Key(KeyEvent {
                code: KeyCode::Char(c),
                ..
            }) => self.scan_char(c),
            Event::Key(KeyEvent {
                code: KeyCode::Backspace,
                ..
            }) => self.scan_backspace(),
            _ => TokenType::None,
        }
    }

    pub(crate) fn scan_backspace(&mut self) -> TokenType {
        if !self.buffer.is_empty() {
            self.buffer.pop();
            TokenType::BackSpace
        } else {
            TokenType::None
        }
    }

    pub(crate) fn scan_ctrl_c(&self) -> TokenType {
        if self.enable_ctrl_c {
            TokenType::Exit
        } else {
            TokenType::None
        }
    }

    pub(crate) fn scan_tab(&mut self) -> TokenType {
        TokenType::Tab(self.buffer.clone())
    }

    pub(crate) fn scan_enter(&mut self) -> TokenType {
        let token = self.buffer.clone();
        TokenType::Token(token)
    }

    pub(crate) fn scan_char(&mut self, c: char) -> TokenType {
        if c.is_alphanumeric() || c == '/' || c == '_' || c == ' ' {
            self.buffer.push(c);
            TokenType::Continue(self.buffer.clone())
        } else {
            TokenType::None
        }
    }

    pub(crate) fn update_buffer(&mut self, new_buffer: String) {
        self.buffer = new_buffer;
    }

    pub(crate) fn clear_buffer(&mut self) {
        self.buffer.clear();
    }
}