navy-nvim-rs 0.0.13

A library for writing neovim rpc clients
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

//! Some manually implemented API functions
use rmpv::{Value, ValueRef};
use tokio::io::AsyncWrite;

use crate::{
    Buffer, Tabpage, Window,
    error::CallError,
    neovim::Neovim,
    rpc::{model::IntoVal, unpack::TryUnpack},
};

impl<W> Neovim<W>
where
    W: AsyncWrite + Send + Unpin + 'static,
{
    pub async fn list_bufs(&self) -> Result<Vec<Buffer<W>>, Box<CallError>> {
        match self.call("nvim_list_bufs", call_args![]).await?? {
            Value::Array(arr) => Ok(arr
                .into_iter()
                .map(|v| Buffer::new(v, self.clone()))
                .collect()),
            val => Err(CallError::WrongValueType(val))?,
        }
    }

    pub async fn get_current_buf(&self) -> Result<Buffer<W>, Box<CallError>> {
        Ok(self
            .call("nvim_get_current_buf", call_args![])
            .await?
            .map(|val| Buffer::new(val, self.clone()))?)
    }

    pub async fn list_wins(&self) -> Result<Vec<Window<W>>, Box<CallError>> {
        match self.call("nvim_list_wins", call_args![]).await?? {
            Value::Array(arr) => Ok(arr
                .into_iter()
                .map(|v| Window::new(v, self.clone()))
                .collect()),
            val => Err(CallError::WrongValueType(val))?,
        }
    }

    pub async fn get_current_win(&self) -> Result<Window<W>, Box<CallError>> {
        Ok(self
            .call("nvim_get_current_win", call_args![])
            .await?
            .map(|val| Window::new(val, self.clone()))?)
    }

    pub async fn create_buf(
        &self,
        listed: bool,
        scratch: bool,
    ) -> Result<Buffer<W>, Box<CallError>> {
        Ok(self
            .call("nvim_create_buf", call_args![listed, scratch])
            .await?
            .map(|val| Buffer::new(val, self.clone()))?)
    }

    pub async fn open_win(
        &self,
        buffer: &Buffer<W>,
        enter: bool,
        config: Vec<(Value, Value)>,
    ) -> Result<Window<W>, Box<CallError>> {
        Ok(self
            .call("nvim_open_win", call_args![buffer, enter, config])
            .await?
            .map(|val| Window::new(val, self.clone()))?)
    }

    pub async fn list_tabpages(&self) -> Result<Vec<Tabpage<W>>, Box<CallError>> {
        match self.call("nvim_list_tabpages", call_args![]).await?? {
            Value::Array(arr) => Ok(arr
                .into_iter()
                .map(|v| Tabpage::new(v, self.clone()))
                .collect()),
            val => Err(CallError::WrongValueType(val))?,
        }
    }

    pub async fn get_current_tabpage(&self) -> Result<Tabpage<W>, Box<CallError>> {
        Ok(self
            .call("nvim_get_current_tabpage", call_args![])
            .await?
            .map(|val| Tabpage::new(val, self.clone()))?)
    }

    pub async fn request_input(&self, keys: &str) -> Result<i64, Box<CallError>> {
        self.call_nvim_input(keys)
            .await??
            .try_unpack()
            .map_err(|v| Box::new(CallError::WrongValueType(v)))
    }

    #[inline]
    pub async fn notify_input(&self, keys: &str) -> Result<(), Box<CallError>> {
        self.notify_string("nvim_input", keys).await
    }

    #[inline]
    pub async fn out_write(&self, str: &str) -> Result<(), Box<CallError>> {
        self.notify_string("nvim_out_write", str).await
    }

    #[inline]
    pub async fn err_write(&self, str: &str) -> Result<(), Box<CallError>> {
        self.notify_string("nvim_err_write", str).await
    }

    #[inline]
    pub async fn err_writeln(&self, str: &str) -> Result<(), Box<CallError>> {
        self.notify_string("nvim_err_writeln", str).await
    }

    #[inline]
    pub async fn ui_set_focus(&self, gained: bool) -> Result<(), Box<CallError>> {
        let args = [ValueRef::Boolean(gained)];
        self.notify_value_ref("nvim_ui_set_focus", &args).await
    }

    #[inline]
    pub async fn ui_try_resize(&self, width: i64, height: i64) -> Result<(), Box<CallError>> {
        let args = [ValueRef::from(width), ValueRef::from(height)];
        self.notify_value_ref("nvim_ui_try_resize", &args).await
    }

    pub async fn cmd_value_ref(
        &self,
        cmd: ValueRef<'_>,
        opts: ValueRef<'_>,
    ) -> Result<String, Box<CallError>> {
        self.call_value_ref("nvim_cmd", &[cmd, opts])
            .await??
            .try_unpack()
            .map_err(|v| Box::new(CallError::WrongValueType(v)))
    }
}