nvim-rs 0.9.2

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

#![allow(unused)]
use nvim_rs::rpc::handler::Dummy as DummyHandler;

#[cfg(feature = "use_tokio")]
use nvim_rs::create::tokio as create;
#[cfg(feature = "use_tokio")]
use tokio::test as atest;

#[cfg(feature = "use_async-std")]
use async_std::test as atest;
#[cfg(feature = "use_async-std")]
use nvim_rs::create::async_std as create;

use std::{
  path::Path,
  process::Command,
  thread::sleep,
  time::{Duration, Instant},
};

#[cfg(unix)]
use tempfile::{Builder, TempDir};

#[path = "../common/mod.rs"]
mod common;
use common::*;

const HOST: &str = "127.0.0.1";
const PORT: u16 = 6666;

#[atest]
async fn can_connect_via_tcp() {
  let listen = HOST.to_string() + ":" + &PORT.to_string();

  let mut child = Command::new(nvim_path())
    .args(&["-u", "NONE", "--headless", "--listen", &listen])
    .spawn()
    .expect("Cannot start neovim");

  // wait at most 1 second for neovim to start and create the tcp socket
  let start = Instant::now();

  let (nvim, _io_handle) = loop {
    sleep(Duration::from_millis(100));

    let handler = DummyHandler::new();
    if let Ok(r) = create::new_tcp(&listen, handler).await {
      break r;
    } else {
      if Duration::from_secs(1) <= start.elapsed() {
        panic!("Unable to connect to neovim via tcp at {}", listen);
      }
    }
  };

  let servername = nvim
    .get_vvar("servername")
    .await
    .expect("Error retrieving servername from neovim");

  child.kill().expect("Could not kill neovim");

  assert_eq!(&listen, servername.as_str().unwrap());
}

#[cfg(unix)]
fn get_socket_path() -> (std::path::PathBuf, TempDir) {
  let dir = Builder::new()
    .prefix("neovim-lib.test")
    .tempdir()
    .expect("Cannot create temporary directory for test.");

  (dir.path().join("unix_socket"), dir)
}

#[cfg(windows)]
fn get_socket_path() -> (std::path::PathBuf, ()) {
  let rand = fastrand::u32(..);
  let name = format!(r"\\.\pipe\nvim-rs-test-{}", rand);
  (name.into(), ())
}

#[cfg(not(all(feature = "use_async-std", windows)))]
#[atest]
async fn can_connect_via_path() {
  let (socket_path, _guard) = get_socket_path();

  let mut child = Command::new(nvim_path())
    .args(&["-u", "NONE", "--headless"])
    .env("NVIM_LISTEN_ADDRESS", &socket_path)
    .spawn()
    .expect("Cannot start neovim");

  // wait at most 1 second for neovim to start and create the socket
  {
    let start = Instant::now();
    let one_second = Duration::from_secs(1);
    loop {
      sleep(Duration::from_millis(100));

      if let Ok(_) = std::fs::metadata(&socket_path) {
        break;
      }

      if one_second <= start.elapsed() {
        panic!("neovim socket not found at '{:?}'", &socket_path);
      }
    }
  }

  let handler = DummyHandler::new();

  let (nvim, _io_handle) = create::new_path(&socket_path, handler)
    .await
    .expect(&format!(
      "Unable to connect to neovim's unix socket at {:?}",
      &socket_path
    ));

  let servername = nvim
    .get_vvar("servername")
    .await
    .expect("Error retrieving servername from neovim")
    .as_str()
    .unwrap()
    .to_string();

  child.kill().expect("Could not kill neovim");

  assert_eq!(socket_path, Path::new(&servername));
}