lsp-cli 0.1.1

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
128
129
130

#![warn(clippy::pedantic)]

mod cli;
mod commands;
mod config;
mod detect;
mod hash;
mod lsp;
mod mason;
mod runtime_state;
mod server_stderr;
mod suggest;
mod system_log;
mod update;

#[cfg(test)]
mod test_support;

use std::env;
use std::process;

use cli::{RawCommand as CliRawCommand, parse_raw_args, resolve_command};
use commands::{run, run_commands, run_completion};
use config::{default_cli_config_roots, default_config_root, load_cli_config, load_config_store};
use system_log::{log_unexpected_error, warn_if_log_file_is_large};

fn main() {
    warn_if_log_file_is_large();
    let cli_argv = env::args().skip(1).collect::<Vec<_>>();
    let raw_command = match parse_raw_args(cli_argv.clone()) {
        Ok(command) => command,
        Err(message) => {
            eprintln!("{message}");
            process::exit(2);
        }
    };

    let output = match raw_command {
        CliRawCommand::Commands(_) => run_commands(),
        CliRawCommand::Completion(completion_args) => run_completion(completion_args),
        CliRawCommand::Update(_) => {
            let cli = match update::load_cli_defaults_for_update() {
                Ok(cli) => cli,
                Err(error) => {
                    log_unexpected_error(&format!("failed to load lsp-cli defaults: {error}"));
                    eprintln!("failed to load lsp-cli defaults: {error}");
                    process::exit(1);
                }
            };
            let command = match resolve_command(raw_command, &cli) {
                Ok(command) => command,
                Err(error) => {
                    eprintln!("{error}");
                    process::exit(2);
                }
            };
            let config = config::ConfigStore {
                filetypes: Vec::new(),
                lsps: Vec::new(),
                cli,
            };
            run(command, &config)
        }
        raw_command => {
            if let Err(error) = update::ensure_data_available() {
                log_unexpected_error(&format!(
                    "failed to install lsp-cli data automatically: {error}"
                ));
                eprintln!("failed to install lsp-cli data automatically: {error}");
                process::exit(1);
            }
            let config_root = match default_config_root() {
                Ok(path) => path,
                Err(error) => {
                    log_unexpected_error(&format!("failed to resolve config root: {error}"));
                    eprintln!("failed to resolve config root: {error}");
                    process::exit(1);
                }
            };

            let mut config = match load_config_store(&config_root) {
                Ok(config) => config,
                Err(error) => {
                    log_unexpected_error(&format!(
                        "failed to load config from {}: {error}",
                        config_root.display()
                    ));
                    eprintln!(
                        "failed to load config from {}: {error}",
                        config_root.display()
                    );
                    process::exit(1);
                }
            };

            let (global_cli_root, user_cli_root) = default_cli_config_roots();
            config.cli = match load_cli_config(&global_cli_root, user_cli_root.as_deref()) {
                Ok(cli) => cli,
                Err(error) => {
                    log_unexpected_error(&format!("failed to load lsp-cli defaults: {error}"));
                    eprintln!("failed to load lsp-cli defaults: {error}");
                    process::exit(1);
                }
            };

            let command = match resolve_command(raw_command, &config.cli) {
                Ok(command) => command,
                Err(error) => {
                    eprintln!("{error}");
                    process::exit(2);
                }
            };

            run(command, &config)
        }
    };

    match output {
        Ok(output) => {
            if !output.is_empty() {
                println!("{output}");
            }
        }
        Err(error) => {
            log_unexpected_error(&error);
            eprintln!("{error}");
            process::exit(1);
        }
    }
}