serialtui 0.1.3

A TUI environment specific to serial connections
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

use super::Command;
use crate::hint::default_hint::DefaultHint;
use rustyline::hint::Hinter;
use rustyline::Context;
use rustyline_derive::{Completer, Helper, Highlighter, Validator};

#[derive(Default, Completer, Helper, Highlighter, Validator)]
pub(crate) struct CommandManager {
    pub commands: Vec<Box<dyn Command>>,
}

impl CommandManager {
    pub fn builder() -> CommandManagerBuilder {
        CommandManagerBuilder::default()
    }

    pub async fn run_command(&self, data: String) -> Vec<u8> {
        let mut tokens = data
            .split_whitespace()
            .map(|s| <String as std::str::FromStr>::from_str(s).unwrap());

        let cmd: Option<String> = tokens.next();

        cmd.map(|name| {
            self.commands
                .iter()
                .find(|command| command.get_name() == name)
                .map(|command| command.run(tokens.collect()))
        })
        .flatten()
        .unwrap_or(Box::pin(CommandManager::fake_command()))
        .await
    }

    fn fake_command() -> impl std::future::Future<Output = Vec<u8>> + Send {
        async { Default::default() }
    }

    fn get_command_hint(&self, tokens: &str, pos: usize) -> Option<DefaultHint> {
        self.commands
            .iter()
            .filter(|command| command.get_name().starts_with(tokens))
            .next()
            .map(|hint| DefaultHint {
                hint: hint.get_name()[pos..].to_string(),
                complete_up_to: hint.get_name().len().saturating_sub(pos),
            })
    }

    fn get_command_args_hint(
        &self,
        command_name: &str,
        args: &Vec<&str>,
        pos: usize,
    ) -> Option<DefaultHint> {
        self.commands
            .iter()
            .filter(|command| command.get_name() == command_name)
            .next()
            .map(|command| {
                args.last()
                    .map(move |input_seq| {
                        command
                            .get_args()
                            .iter()
                            .filter(|arg_name| arg_name.starts_with(input_seq))
                            .next()
                            .map(|hint| DefaultHint {
                                hint: hint[pos..].to_string(),
                                complete_up_to: hint.len().saturating_sub(pos),
                            })
                    })
                    .flatten()
            })
            .flatten()
    }
}

impl Hinter for CommandManager {
    type Hint = DefaultHint;

    fn hint(&self, line: &str, pos: usize, _ctx: &Context<'_>) -> std::option::Option<DefaultHint> {
        if line.is_empty() || pos < line.len() {
            return None;
        }

        let mut tokens: Vec<_> = line.split_whitespace().collect();

        let pos = if line.ends_with(' ') { pos - 1 } else { pos };

        if tokens.len() == 1 {
            self.get_command_hint(tokens[0], pos)
        } else if tokens.len() == 0 {
            Option::None
        } else {
            let command = tokens.remove(0);
            self.get_command_args_hint(command, &tokens, pos)
        }
    }
}

#[derive(Default)]
pub(crate) struct CommandManagerBuilder {
    commands: Vec<Box<dyn Command>>,
}

impl CommandManagerBuilder {
    pub(crate) fn commands(mut self, commands: Vec<Box<dyn Command>>) -> CommandManagerBuilder {
        self.commands = commands;
        self
    }

    pub(crate) fn build(self) -> CommandManager {
        CommandManager {
            commands: self.commands,
        }
    }
}