nui 0.0.1

Experimental neovim RPC for UI clients
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

use rmpv::Value;

use super::ParseError;

#[derive(Debug)]
pub struct HighlightAttributeDefine {
    pub id: i64,
    pub rgb: Option<Vec<(String, String)>>,
    pub cterm: Option<Vec<(String, String)>>,
    pub info: Option<i64>,
}

impl TryFrom<&Vec<Value>> for HighlightAttributeDefine {
    type Error = ParseError;

    fn try_from(values: &Vec<Value>) -> Result<Self, Self::Error> {
        dbg!(&values);

        Ok(Self {
            id: 1,
            rgb: None,
            cterm: None,
            info: None,
        })
    }
}

#[derive(Debug)]
pub struct HighlightGroupSet {
    pub name: String,
    pub hl_id: i64,
}

impl TryFrom<&Vec<Value>> for HighlightGroupSet {
    type Error = ParseError;

    fn try_from(values: &Vec<Value>) -> Result<Self, Self::Error> {
        dbg!(&values);

        Ok(Self {
            name: String::from("test"),
            hl_id: 1,
        })
    }
}

#[derive(Debug)]
pub struct GridLineCell {
    pub text: String,
    pub hl_id: Option<i64>,
    pub repeat: Option<i64>,
}

impl TryFrom<&Value> for GridLineCell {
    type Error = ParseError;

    fn try_from(value: &Value) -> Result<Self, Self::Error> {
        let cell = value.as_array().unwrap();
        let text = cell.get(0).unwrap().as_str().unwrap().to_owned();
        let hl_id = match cell.get(1) {
            Some(value) => Some(value.as_i64().unwrap()),
            None => None,
        };
        let repeat = match cell.get(2) {
            Some(value) => Some(value.as_i64().unwrap()),
            None => None,
        };

        Ok(Self {
            text,
            hl_id,
            repeat,
        })
    }
}

#[derive(Debug)]
pub struct GridLine {
    pub grid: i64,
    pub row: i64,
    pub column_start: i64,
    pub cells: Vec<GridLineCell>,
}

impl TryFrom<&Vec<Value>> for GridLine {
    type Error = ParseError;

    fn try_from(value: &Vec<Value>) -> Result<Self, Self::Error> {
        let grid = value.get(0).unwrap().as_i64().unwrap();
        let row = value.get(1).unwrap().as_i64().unwrap();
        let column_start = value.get(2).unwrap().as_i64().unwrap();
        let cells = value.get(3).unwrap().as_array().unwrap().into_iter();

        let mut parsed_cells = Vec::<GridLineCell>::with_capacity(cells.len());
        for cell in cells {
            if let Ok(cell) = GridLineCell::try_from(cell) {
                parsed_cells.push(cell);
            }
        }

        Ok(GridLine {
            grid,
            row,
            column_start,
            cells: parsed_cells,
        })
    }
}

#[derive(Debug)]
pub struct GridClear {
    pub grid: i64,
}

impl TryFrom<&Vec<Value>> for GridClear {
    type Error = ParseError;

    fn try_from(values: &Vec<Value>) -> Result<Self, Self::Error> {
        todo!();
    }
}

#[derive(Debug)]
pub struct GridDestroy {
    pub grid: i64,
}

impl TryFrom<&Vec<Value>> for GridDestroy {
    type Error = ParseError;

    fn try_from(values: &Vec<Value>) -> Result<Self, Self::Error> {
        todo!();
    }
}

#[derive(Debug)]
pub struct GridResize {
    pub grid: i64,
    pub width: i64,
    pub height: i64,
}

impl TryFrom<&Vec<Value>> for GridResize {
    type Error = ParseError;

    fn try_from(value: &Vec<Value>) -> Result<Self, Self::Error> {
        todo!()
    }
}

#[derive(Debug)]
pub struct GridCursorGoto {
    pub grid: i64,
    pub row: i64,
    pub column: i64,
}

impl TryFrom<&Vec<Value>> for GridCursorGoto {
    type Error = ParseError;

    fn try_from(value: &Vec<Value>) -> Result<Self, Self::Error> {
        todo!()
    }
}

#[derive(Debug)]
pub struct GridScroll {
    pub grid: i64,
    pub top: i64,
    pub bottom: i64,
    pub left: i64,
    pub right: i64,
    pub rows: i64,
    pub columns: i64,
}

impl TryFrom<&Vec<Value>> for GridScroll {
    type Error = ParseError;

    fn try_from(value: &Vec<Value>) -> Result<Self, Self::Error> {
        todo!()
    }
}