nu-cli 0.112.1

CLI-related functionality for Nushell
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
124
125
126
127
128
129
130
131
132
133
134

use nu_engine::command_prelude::*;
use reedline::{
    EditCommandDiscriminants, ReedlineEventDiscriminants, get_reedline_keybinding_modifiers,
    get_reedline_keycodes, get_reedline_prompt_edit_modes,
};
use strum::VariantArray;

use crate::reedline_config::{display_edit_command, display_reedline_event};

#[derive(Clone)]
pub struct KeybindingsList;

impl Command for KeybindingsList {
    fn name(&self) -> &str {
        "keybindings list"
    }

    fn signature(&self) -> Signature {
        Signature::build(self.name())
            .input_output_types(vec![(Type::Nothing, Type::table())])
            .switch("modifiers", "List of modifiers.", Some('m'))
            .switch("keycodes", "List of keycodes.", Some('k'))
            .switch("modes", "List of edit modes.", Some('o'))
            .switch("events", "List of reedline event.", Some('e'))
            .switch("edits", "List of edit commands.", Some('d'))
            .category(Category::Platform)
    }

    fn description(&self) -> &str {
        "List available options that can be used to create keybindings."
    }

    fn examples(&self) -> Vec<Example<'_>> {
        vec![
            Example {
                description: "Get list of key modifiers",
                example: "keybindings list --modifiers",
                result: None,
            },
            Example {
                description: "Get list of reedline events and edit commands",
                example: "keybindings list -e -d",
                result: None,
            },
            Example {
                description: "Get list with all the available options",
                example: "keybindings list",
                result: None,
            },
        ]
    }

    fn run(
        &self,
        engine_state: &EngineState,
        stack: &mut Stack,
        call: &Call,
        _input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        let all_options = ["modifiers", "keycodes", "edits", "modes", "events"];

        let presence = all_options
            .iter()
            .map(|option| call.has_flag(engine_state, stack, option))
            .collect::<Result<Vec<_>, ShellError>>()?;

        let no_option_specified = presence.iter().all(|present| !*present);

        let records = all_options
            .iter()
            .zip(presence)
            .filter(|(_, present)| no_option_specified || *present)
            .flat_map(|(option, _)| get_records(option, call.head))
            .collect();

        Ok(Value::list(records, call.head).into_pipeline_data())
    }
}

fn get_records(entry_type: &str, span: Span) -> Vec<Value> {
    let values = match entry_type {
        "modifiers" => get_reedline_keybinding_modifiers().sorted(),
        "keycodes" => get_reedline_keycodes().sorted(),
        "edits" => get_reedline_edit_commands().sorted(),
        "modes" => get_reedline_prompt_edit_modes().sorted(),
        "events" => get_reedline_reedline_events().sorted(),
        _ => Vec::new(),
    };

    values
        .iter()
        .map(|edit| edit.split('\n'))
        .flat_map(|edit| edit.map(|edit| convert_to_record(edit, entry_type, span)))
        .collect()
}

fn get_reedline_edit_commands() -> Vec<String> {
    EditCommandDiscriminants::VARIANTS
        .iter()
        .filter_map(|edit| display_edit_command(*edit).map(|s| s.to_string()))
        .collect()
}

fn get_reedline_reedline_events() -> Vec<String> {
    ReedlineEventDiscriminants::VARIANTS
        .iter()
        .filter_map(|event| display_reedline_event(*event).map(|s| s.to_string()))
        .collect()
}

fn convert_to_record(edit: &str, entry_type: &str, span: Span) -> Value {
    Value::record(
        record! {
            "type" => Value::string(entry_type, span),
            "name" => Value::string(edit, span),
        },
        span,
    )
}

// Helper to sort a vec and return a vec
trait SortedImpl {
    fn sorted(self) -> Self;
}

impl<E> SortedImpl for Vec<E>
where
    E: std::cmp::Ord,
{
    fn sorted(mut self) -> Self {
        self.sort();
        self
    }
}