crabterm 0.1.0

A terminal (UART) server and client
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use mio::unix::SourceFd;
use mio::{Interest, Poll, Token};
use std::io::{ErrorKind, Read, Result, Write};
use std::os::unix::io::AsRawFd;

use crate::iofilter::FilterChain;
use crate::keybind::action::Action;
use crate::keybind::{KeybindConfig, KeybindProcessor, KeybindResult};
use crate::term::{disable_raw_mode, enable_raw_mode};
use crate::traits::{IoInstance, IoResult};

pub struct Console {
    fd_in: SourceFd<'static>,
    keybind_processor: KeybindProcessor,
    pending_results: Vec<KeybindResult>,
    filter_chain: FilterChain,
}

impl Console {
    pub fn new(keybind_config: KeybindConfig, filter_chain: FilterChain) -> Result<Self> {
        // stdin is a global and its FD is valid for the entire program
        let fd = std::io::stdin().as_raw_fd();

        enable_raw_mode()?;

        let fd_ref: &'static i32 = Box::leak(Box::new(fd)); // convert to 'static lifetime

        Ok(Console {
            fd_in: SourceFd(fd_ref),
            keybind_processor: KeybindProcessor::new(keybind_config),
            pending_results: Vec::new(),
            filter_chain,
        })
    }

    fn keybind_result_to_read_result(&mut self, result: KeybindResult) -> Option<IoResult> {
        match result {
            KeybindResult::Passthrough(bytes) => {
                let filtered = self.filter_chain.filter_in(&bytes);
                Some(IoResult::Data(filtered))
            }
            KeybindResult::Action(Action::FilterToggle(name)) => {
                self.filter_chain.toggle(&name);
                None
            }
            KeybindResult::Action(action) => Some(IoResult::Action(action)),
            KeybindResult::Consumed => None,
        }
    }

    fn apply_filter(&mut self, buf: &[u8]) -> Vec<u8> {
        self.filter_chain.filter_out(buf)
    }
}

impl IoInstance for Console {
    fn connect(&mut self, poll: &mut Poll, token: Token) -> Result<()> {
        poll.registry()
            .register(&mut self.fd_in, token, Interest::READABLE)
    }

    fn addr_as_string(&self) -> String {
        "Console".to_owned()
    }

    fn connected(&self) -> bool {
        true
    }

    fn disconnect(&mut self, poll: &mut Poll) {
        // TODO, panic on error?
        let _ = poll.registry().deregister(&mut self.fd_in);
    }

    fn read(&mut self) -> Result<IoResult> {
        // First, check if we have pending results from previous processing
        if let Some(result) = self.pending_results.pop()
            && let Some(read_result) = self.keybind_result_to_read_result(result)
        {
            return Ok(read_result);
        }

        let mut tmp = [0u8; 1024];

        match std::io::stdin().read(&mut tmp) {
            Ok(0) => Ok(IoResult::None),

            Ok(n) => {
                // Process through keybind processor
                let results = self.keybind_processor.process(&tmp[..n]);

                // Store results in reverse order so we can pop from the end
                for result in results.into_iter().rev() {
                    self.pending_results.push(result);
                }

                // Return the first result
                if let Some(result) = self.pending_results.pop()
                    && let Some(read_result) = self.keybind_result_to_read_result(result)
                {
                    return Ok(read_result);
                }

                Ok(IoResult::None)
            }

            Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
                // Not ready yet — ignore and wait for next event
                Ok(IoResult::None)
            }

            Err(e) => Err(e),
        }
    }

    fn tick(&mut self) -> Result<IoResult> {
        // Check for timeout-triggered results (e.g., escape key timeout, prefix timeout)
        let results = self.keybind_processor.tick();

        for result in results.into_iter().rev() {
            self.pending_results.push(result);
        }

        if let Some(result) = self.pending_results.pop()
            && let Some(read_result) = self.keybind_result_to_read_result(result)
        {
            return Ok(read_result);
        }

        Ok(IoResult::None)
    }

    fn write(&mut self, buf: &[u8]) -> Result<IoResult> {
        let filtered = self.apply_filter(buf);
        match std::io::stdout().write_all(&filtered) {
            Ok(()) => Ok(IoResult::Data(buf.to_vec())),
            Err(e) => Err(e),
        }
    }

    fn flush(&mut self) {
        // TODO, error handle
        let _ = std::io::stdout().flush();
    }
}

impl Drop for Console {
    fn drop(&mut self) {
        let _ = disable_raw_mode();
    }
}