vimvar 0.3.0

Library that provides ability to read neovim/vim variables
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

use serde_json::json;
use tempfile::{NamedTempFile, TempPath};
use vimvar::*;

static TEST_VIMRC: &str = r#"
let b:my_buffer_var = 'some buffer value'
let w:my_window_var = 'some window value'
let t:my_tabpage_var = 'some tabpage value'
let g:my_global_var = 'some global value'
"#;

fn make_test_vimrc() -> TempPath {
    use std::io::Write;
    let mut file = NamedTempFile::new().unwrap();
    file.as_file_mut().write_all(TEST_VIMRC.as_bytes()).unwrap();
    file.into_temp_path()
}

macro_rules! impl_tests {
    ($cmd:expr) => {
        #[test]
        fn can_load_buffer_variable() {
            let path = make_test_vimrc();

            let var = VimVar::new($cmd, Scope::Buffer, "my_buffer_var");
            let value = var
                .load_with_config(path, false)
                .expect("Failed to load variable");

            assert_eq!(value, Some(json!("some buffer value")));
        }

        #[test]
        fn can_load_window_variable() {
            let path = make_test_vimrc();

            let var = VimVar::new($cmd, Scope::Window, "my_window_var");
            let value = var
                .load_with_config(path, false)
                .expect("Failed to load variable");

            assert_eq!(value, Some(json!("some window value")));
        }

        #[test]
        fn can_load_tabpage_variable() {
            let path = make_test_vimrc();

            let var = VimVar::new($cmd, Scope::Tabpage, "my_tabpage_var");
            let value = var
                .load_with_config(path, false)
                .expect("Failed to load variable");

            assert_eq!(value, Some(json!("some tabpage value")));
        }

        #[test]
        fn can_load_global_variable() {
            let path = make_test_vimrc();

            let var = VimVar::new($cmd, Scope::Global, "my_global_var");
            let value = var
                .load_with_config(path, false)
                .expect("Failed to load variable");

            assert_eq!(value, Some(json!("some global value")));
        }

        #[test]
        fn can_load_variable_as_specific_type() {
            let path = make_test_vimrc();

            let var = VimVar::new($cmd, Scope::Global, "my_global_var");
            let value: Option<String> = var
                .load_typed_with_config(path, false)
                .expect("Failed to load variable");

            assert_eq!(value.as_deref(), Some("some global value"));
        }

        #[test]
        fn reports_error_when_loading_variable_as_wrong_specific_type() {
            let path = make_test_vimrc();

            let var = VimVar::new($cmd, Scope::Global, "my_global_var");
            let result = var.load_typed_with_config::<_, usize>(path, false);

            assert_eq!(result.is_err(), true);
        }
    };
}

mod nvim {
    use super::*;
    impl_tests!(Cmd::Neovim);
}

mod vim {
    use super::*;
    impl_tests!(Cmd::Vim);
}