shelljougahara 0.0.2

A simulated shell written in Rust.
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

//! The history command, printing the history of commands.

use crate::{
    commands::{
        Argument, CommandOutput, ExecutableCommand, Flags,
        args::{ArgumentKind, BasicArgument, BasicArgumentKind},
        flags::{FlagDefinition, FlagDefinitionBuilder},
    },
    errors::ShellError,
};

#[derive(Default, Clone, Copy)]
pub struct HistoryCommand;

impl ExecutableCommand for HistoryCommand {
    fn name(&self) -> &'static str {
        "history"
    }

    fn flags(&self) -> FlagDefinition {
        FlagDefinitionBuilder::new().into_flag_definition()
    }

    fn args(&self) -> Option<ArgumentKind> {
        Some(ArgumentKind::Basic(BasicArgumentKind::Integer))
    }

    fn execute(
        &self,
        _: Flags,
        args: Option<Argument>,
        shell: &mut crate::shell::Shell,
    ) -> Result<CommandOutput, ShellError> {
        let history = shell.current_session.get_history();

        let history_iter = history.iter().enumerate();

        let history = match args {
            Some(Argument::Basic(BasicArgument::Integer(limit))) => {
                history_iter.take(limit as usize).collect::<Vec<_>>()
            }
            Some(_) => return Err(ShellError::Internal("Invalid argument".to_string())),
            None => history_iter.collect::<Vec<_>>(),
        };

        let history = history
            .into_iter()
            .map(|(index, command)| format!("{:>5} {}", index + 1, command))
            .collect::<Vec<String>>()
            .join("\n");

        Ok(CommandOutput(if history.is_empty() {
            None
        } else {
            Some(history)
        }))
    }
}