nu-protocol 0.112.1

Nushell's internal protocols, including its abstract syntax tree
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

use super::{config_update_string_enum, prelude::*};

use crate::{self as nu_protocol};

#[derive(Clone, Copy, Default, Debug, IntoValue, PartialEq, Eq, Serialize, Deserialize)]
pub enum ErrorStyle {
    #[default]
    Fancy,
    Plain,
    Short,
    Nested,
}

impl FromStr for ErrorStyle {
    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "fancy" => Ok(Self::Fancy),
            "plain" => Ok(Self::Plain),
            "short" => Ok(Self::Short),
            "nested" => Ok(Self::Nested),
            _ => Err("'fancy', 'plain', 'short' or 'nested'"),
        }
    }
}

impl UpdateFromValue for ErrorStyle {
    fn update(&mut self, value: &Value, path: &mut ConfigPath, errors: &mut ConfigErrors) {
        config_update_string_enum(self, value, path, errors)
    }
}

/// Option: show_banner
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum BannerKind {
    /// No banner on startup
    None,
    /// Abbreviated banner just containing the startup-time
    Short,
    /// The full banner including Ellie
    #[default]
    Full,
}

impl IntoValue for BannerKind {
    fn into_value(self, span: Span) -> Value {
        match self {
            // This uses a custom implementation to reflect common config
            // bool: true, false was used for a long time
            // string: short was added later
            BannerKind::None => Value::bool(false, span),
            BannerKind::Short => Value::string("short", span),
            BannerKind::Full => Value::bool(true, span),
        }
    }
}

impl UpdateFromValue for BannerKind {
    fn update<'a>(
        &mut self,
        value: &'a Value,
        path: &mut ConfigPath<'a>,
        errors: &mut ConfigErrors,
    ) {
        match value {
            Value::Bool { val, .. } => match val {
                true => {
                    *self = BannerKind::Full;
                }
                false => {
                    *self = BannerKind::None;
                }
            },
            Value::String { val, .. } => match val.as_str() {
                "true" => {
                    *self = BannerKind::Full;
                }
                "full" => {
                    *self = BannerKind::Full;
                }
                "short" => {
                    *self = BannerKind::Short;
                }
                "false" => {
                    *self = BannerKind::None;
                }
                "none" => {
                    *self = BannerKind::None;
                }
                _ => {
                    errors.invalid_value(path, "true/'full', 'short', false/'none'", value);
                }
            },
            _ => {
                errors.invalid_value(path, "true/'full', 'short', false/'none'", value);
            }
        }
    }
}