nvim-api 0.2.0

Neovim API bindings
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

//! Utility functions for deserializing values coming from Neovim.

use serde::de::{self, Deserialize, Deserializer, IntoDeserializer};

pub(crate) fn bool_from_int<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match u8::deserialize(deserializer)? {
        0 => Ok(false),
        1 => Ok(true),

        other => Err(de::Error::invalid_value(
            de::Unexpected::Unsigned(other as u64),
            &"zero or one",
        )),
    }
}

pub(crate) fn char_from_string<'de, D>(
    deserializer: D,
) -> Result<Option<char>, D::Error>
where
    D: Deserializer<'de>,
{
    let str = String::deserialize(deserializer)?;
    match str.len() {
        0 => Ok(None),
        1 => Ok(str.chars().next()),
        other => Err(de::Error::invalid_length(
            other,
            &"empty string or string with a single character",
        )),
    }
}

pub(crate) fn empty_string_is_none<'de, D, T>(
    deserializer: D,
) -> Result<Option<T>, D::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,
{
    let str = Option::<String>::deserialize(deserializer)?;

    match str {
        None => Ok(None),
        Some(s) if s.is_empty() => Ok(None),
        Some(s) => T::deserialize(s.into_deserializer()).map(Some),
    }
}

pub(crate) fn minus_one_is_none<'de, D, T>(
    deserializer: D,
) -> Result<Option<T>, D::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,
{
    let num = i64::deserialize(deserializer)?;

    match num {
        -1 => Ok(None),
        n => T::deserialize(n.into_deserializer()).map(Some),
    }
}

pub(crate) fn none_literal_is_none<'de, D, T>(
    deserializer: D,
) -> Result<Option<T>, D::Error>
where
    D: de::Deserializer<'de>,
    T: Deserialize<'de>,
{
    let str = Option::<String>::deserialize(deserializer)?;

    match str {
        None => Ok(None),
        Some(s) if s == "none" => Ok(None),
        Some(s) => T::deserialize(s.into_deserializer()).map(Some),
    }
}

pub(crate) fn zero_is_none<'de, D, T>(
    deserializer: D,
) -> Result<Option<T>, D::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,
{
    let num = i64::deserialize(deserializer)?;

    match num {
        0 => Ok(None),
        n => T::deserialize(n.into_deserializer()).map(Some),
    }
}