nu-command 0.106.0

Nushell's built-in commands
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use nu_engine::command_prelude::*;

#[derive(Clone)]
pub struct DecodeHex;

impl Command for DecodeHex {
    fn name(&self) -> &str {
        "decode hex"
    }

    fn signature(&self) -> Signature {
        Signature::build("decode hex")
            .input_output_types(vec![(Type::String, Type::Binary)])
            .category(Category::Formats)
    }

    fn description(&self) -> &str {
        "Hex decode a value."
    }

    fn examples(&self) -> Vec<Example> {
        vec![
            Example {
                description: "Decode arbitrary binary data",
                example: r#""09FD" | decode hex"#,
                result: Some(Value::test_binary(vec![0x09, 0xFD])),
            },
            Example {
                description: "Lowercase Hex is also accepted",
                example: r#""09fd" | decode hex"#,
                result: Some(Value::test_binary(vec![0x09, 0xFD])),
            },
        ]
    }

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

    fn run(
        &self,
        engine_state: &EngineState,
        stack: &mut Stack,
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        super::decode(data_encoding::HEXLOWER_PERMISSIVE, call.head, input)
    }

    fn run_const(
        &self,
        working_set: &StateWorkingSet,
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        super::decode(data_encoding::HEXLOWER_PERMISSIVE, call.span(), input)
    }
}

#[derive(Clone)]
pub struct EncodeHex;

impl Command for EncodeHex {
    fn name(&self) -> &str {
        "encode hex"
    }

    fn signature(&self) -> Signature {
        Signature::build("encode hex")
            .input_output_types(vec![
                (Type::String, Type::String),
                (Type::Binary, Type::String),
            ])
            .switch("lower", "Encode to lowercase hex.", None)
            .category(Category::Formats)
    }

    fn description(&self) -> &str {
        "Hex encode a binary value or a string."
    }

    fn examples(&self) -> Vec<Example> {
        vec![
            Example {
                description: "Encode a binary value",
                example: r#"0x[C3 06] | encode hex"#,
                result: Some(Value::test_string("C306")),
            },
            Example {
                description: "Encode a string",
                example: r#""hello" | encode hex"#,
                result: Some(Value::test_string("68656C6C6F")),
            },
            Example {
                description: "Output a Lowercase version of the encoding",
                example: r#"0x[AD EF] | encode hex --lower"#,
                result: Some(Value::test_string("adef")),
            },
        ]
    }

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

    fn run(
        &self,
        engine_state: &EngineState,
        stack: &mut Stack,
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        let encoding = if call.has_flag(engine_state, stack, "lower")? {
            data_encoding::HEXLOWER
        } else {
            data_encoding::HEXUPPER
        };

        super::encode(encoding, call.head, input)
    }

    fn run_const(
        &self,
        working_set: &StateWorkingSet,
        call: &Call,
        input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        let encoding = if call.has_flag_const(working_set, "lower")? {
            data_encoding::HEXLOWER
        } else {
            data_encoding::HEXUPPER
        };

        super::encode(encoding, call.head, input)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_examples_decode() {
        crate::test_examples(DecodeHex)
    }

    #[test]
    fn test_examples_encode() {
        crate::test_examples(EncodeHex)
    }
}