lsp-cli 0.1.0

Command-line tool for talking to Language Server Protocol (LSP) servers from the terminal.
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

use regex::Regex;
use std::collections::BTreeMap;
use std::sync::OnceLock;

pub struct TemplateContext<'a> {
    pub version: &'a str,
    pub source_asset_bin: Option<&'a str>,
    pub source_asset_file: Option<&'a str>,
    pub source_asset_ext: Option<&'a str>,
    pub source_download_bin: Option<&'a str>,
    pub source_download_config: Option<&'a str>,
    pub source_download_man: Option<&'a str>,
    pub source_asset_named_bins: BTreeMap<String, String>,
}

impl TemplateContext<'_> {
    #[must_use]
    pub fn render(&self, input: &str) -> String {
        template_regex()
            .replace_all(input, |captures: &regex::Captures<'_>| {
                self.render_expression(captures.get(1).map_or("", |capture| capture.as_str()))
                    .unwrap_or_else(|| captures[0].to_string())
            })
            .into_owned()
    }

    fn render_expression(&self, expression: &str) -> Option<String> {
        let expression = expression.trim();

        match expression {
            "version" => Some(self.version.to_string()),
            "version | strip_prefix \"v\"" => Some(
                self.version
                    .strip_prefix('v')
                    .unwrap_or(self.version)
                    .to_string(),
            ),
            "source.asset.bin" => Some(self.source_asset_bin.unwrap_or("").to_string()),
            "source.asset.file" => Some(self.source_asset_file.unwrap_or("").to_string()),
            "source.asset.ext" => Some(self.source_asset_ext.unwrap_or("").to_string()),
            "source.download.bin" => Some(self.source_download_bin.unwrap_or("").to_string()),
            "source.download.config" => Some(self.source_download_config.unwrap_or("").to_string()),
            "source.download.man" => Some(self.source_download_man.unwrap_or("").to_string()),
            _ => expression
                .strip_prefix("source.asset.bin.")
                .and_then(|name| self.source_asset_named_bins.get(name).cloned()),
        }
    }

    #[must_use]
    pub(crate) fn empty() -> Self {
        Self {
            version: "",
            source_asset_bin: None,
            source_asset_file: None,
            source_asset_ext: None,
            source_download_bin: None,
            source_download_config: None,
            source_download_man: None,
            source_asset_named_bins: BTreeMap::new(),
        }
    }
}

fn template_regex() -> &'static Regex {
    static REGEX: OnceLock<Regex> = OnceLock::new();
    REGEX.get_or_init(|| Regex::new(r"\{\{\s*(.*?)\s*\}\}").expect("template regex should compile"))
}

#[cfg(test)]
mod tests {
    use super::TemplateContext;
    use std::collections::BTreeMap;

    #[test]
    fn renders_common_mason_templates() {
        let context = TemplateContext {
            version: "v1.2.3",
            source_asset_bin: Some("exec:libexec/bin/server"),
            source_asset_file: Some("server-v1.2.3.tar.gz"),
            source_asset_ext: Some(".exe"),
            source_download_bin: Some("bzl"),
            source_download_config: Some("config_linux/"),
            source_download_man: Some("quick-lint-js/share/man/"),
            source_asset_named_bins: BTreeMap::from([(
                "lsp".to_string(),
                "exec:language_server.sh".to_string(),
            )]),
        };

        assert_eq!(context.render("{{version}}"), "v1.2.3");
        assert_eq!(
            context.render("{{ version | strip_prefix \"v\" }}"),
            "1.2.3"
        );
        assert_eq!(
            context.render("{{source.asset.bin}}"),
            "exec:libexec/bin/server"
        );
        assert_eq!(
            context.render("{{source.asset.file}}"),
            "server-v1.2.3.tar.gz"
        );
        assert_eq!(context.render("tool{{source.asset.ext}}"), "tool.exe");
        assert_eq!(context.render("{{source.download.bin}}"), "bzl");
        assert_eq!(
            context.render("{{source.download.config}}"),
            "config_linux/"
        );
        assert_eq!(
            context.render("{{source.download.man}}"),
            "quick-lint-js/share/man/"
        );
        assert_eq!(
            context.render("{{ source.asset.bin.lsp }}"),
            "exec:language_server.sh"
        );
    }

    #[test]
    fn renders_missing_known_values_as_empty_strings() {
        let context = TemplateContext::empty();

        assert_eq!(context.render("ast-grep{{source.asset.ext}}"), "ast-grep");
        assert_eq!(context.render("{{source.download.man}}"), "");
    }
}