lex-lsp 0.7.0

Language Server Protocol implementation for the lex format
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

use lex_lsp::LexLanguageServer;
use std::env;
use std::fs;
use std::process::ExitCode;
use tokio::io::{stdin, stdout};
use tower_lsp::{LspService, Server};

#[tokio::main]
async fn main() -> ExitCode {
    eprintln!("DEBUG: lex-lsp starting up (Commit 1)...");
    let args: Vec<String> = env::args().collect();

    // If called with "convert" subcommand, handle it and exit
    if args.len() >= 2 && args[1] == "convert" {
        return handle_convert(&args[2..]);
    }

    // Default: run as LSP server
    let stdin = stdin();
    let stdout = stdout();
    let (service, socket) = LspService::new(LexLanguageServer::new);
    Server::new(stdin, stdout, socket).serve(service).await;
    ExitCode::SUCCESS
}

fn handle_convert(args: &[String]) -> ExitCode {
    use lex_babel::format::SerializedDocument;
    use lex_babel::registry::FormatRegistry;
    use std::collections::HashMap;

    let mut input_path: Option<&str> = None;
    let mut output_path: Option<&str> = None;
    let mut to_format: Option<&str> = None;
    let mut extra_options: HashMap<String, String> = HashMap::new();

    let mut i = 0;
    while i < args.len() {
        let arg = &args[i];
        if arg == "--to" && i + 1 < args.len() {
            to_format = Some(&args[i + 1]);
            i += 2;
        } else if (arg == "-o" || arg == "--output") && i + 1 < args.len() {
            output_path = Some(&args[i + 1]);
            i += 2;
        } else if arg.starts_with("--extra-") {
            let key = arg.strip_prefix("--extra-").unwrap().to_string();
            let value = if i + 1 < args.len() && !args[i + 1].starts_with("-") {
                i += 1;
                args[i].clone()
            } else {
                "true".to_string()
            };
            extra_options.insert(key, value);
            i += 1;
        } else if !arg.starts_with("-") && input_path.is_none() {
            input_path = Some(arg);
            i += 1;
        } else {
            i += 1;
        }
    }

    let Some(input) = input_path else {
        eprintln!("Error: No input file specified");
        return ExitCode::FAILURE;
    };

    let Some(format) = to_format else {
        eprintln!("Error: No output format specified (use --to)");
        return ExitCode::FAILURE;
    };

    let Some(output) = output_path else {
        eprintln!("Error: No output path specified (use -o)");
        return ExitCode::FAILURE;
    };

    let source = match fs::read_to_string(input) {
        Ok(s) => s,
        Err(e) => {
            eprintln!("Error reading {input}: {e}");
            return ExitCode::FAILURE;
        }
    };

    let registry = FormatRegistry::default();
    let doc = match registry.parse(&source, "lex") {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error parsing {input}: {e}");
            return ExitCode::FAILURE;
        }
    };

    let result = match registry.serialize_with_options(&doc, format, &extra_options) {
        Ok(r) => r,
        Err(e) => {
            eprintln!("Error converting to {format}: {e}");
            return ExitCode::FAILURE;
        }
    };

    let write_result = match result {
        SerializedDocument::Text(text) => fs::write(output, text),
        SerializedDocument::Binary(bytes) => fs::write(output, bytes),
    };

    if let Err(e) = write_result {
        eprintln!("Error writing {output}: {e}");
        return ExitCode::FAILURE;
    }

    ExitCode::SUCCESS
}