corsa 0.1.0

Production-oriented Rust bindings, orchestration layers, and Node integration for typescript-go
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 crate::{Result, jsonrpc};
use corsa::fast::{CompactString, FastMap};
use corsa::jsonrpc::{RawMessage, RequestId};
use corsa::lsp::{VirtualChange, VirtualDocument};
use lsp_types::{
    DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
};
use serde_json::{Value, json};
use std::io::{BufReader, BufWriter};

pub fn run() -> Result<()> {
    let stdin = std::io::stdin();
    let stdout = std::io::stdout();
    let mut reader = BufReader::new(stdin.lock());
    let mut writer = BufWriter::new(stdout.lock());
    let mut last_configuration = Value::Null;
    let mut documents = FastMap::<CompactString, VirtualDocument>::default();
    loop {
        let Some(message) = jsonrpc::read_message(&mut reader)? else {
            return Ok(());
        };
        let method = message.method.unwrap_or_default();
        let params = message.params.unwrap_or(Value::Null);
        match (message.id, method.as_str()) {
            (Some(id), "initialize") => {
                jsonrpc::write_message(
                    &mut writer,
                    &RawMessage::response(
                        id,
                        json!({
                            "capabilities": { "textDocumentSync": 1 },
                            "serverInfo": { "name": "mock-tsgo" }
                        }),
                    ),
                )?;
                jsonrpc::write_message(
                    &mut writer,
                    &RawMessage::notification(
                        "window/logMessage",
                        json!({
                            "type": 3,
                            "message": "mock initialized"
                        }),
                    ),
                )?;
            }
            (Some(id), "custom/initializeAPISession") => {
                jsonrpc::write_message(
                    &mut writer,
                    &RawMessage::response(
                        id,
                        json!({
                            "sessionId": "session-1",
                            "pipe": "/tmp/mock-tsgo.sock"
                        }),
                    ),
                )?;
            }
            (Some(id), "custom/lastConfiguration") => {
                jsonrpc::write_message(
                    &mut writer,
                    &RawMessage::response(id, last_configuration.clone()),
                )?;
            }
            (Some(id), "custom/overlayState") => {
                jsonrpc::write_message(
                    &mut writer,
                    &RawMessage::response(
                        id,
                        json!({
                            "documents": documents.values().cloned().collect::<Vec<_>>()
                        }),
                    ),
                )?;
            }
            (Some(id), _) => {
                jsonrpc::write_message(&mut writer, &RawMessage::response(id, Value::Null))?;
            }
            (None, "initialized") => {
                last_configuration = jsonrpc::send_request(
                    &mut reader,
                    &mut writer,
                    RequestId::integer(99),
                    "workspace/configuration",
                    json!({ "items": [{ "section": "typescript" }] }),
                )?;
            }
            (None, "textDocument/didOpen") => {
                let params: DidOpenTextDocumentParams = serde_json::from_value(params)?;
                let document = VirtualDocument::from_item(params.text_document);
                documents.insert(document.key(), document);
            }
            (None, "textDocument/didChange") => {
                let params: DidChangeTextDocumentParams = serde_json::from_value(params)?;
                if let Some(document) = documents.get_mut(params.text_document.uri.as_str()) {
                    let changes = params
                        .content_changes
                        .into_iter()
                        .map(VirtualChange::from)
                        .collect::<Vec<_>>();
                    document.apply_changes(&changes)?;
                }
            }
            (None, "textDocument/didClose") => {
                let params: DidCloseTextDocumentParams = serde_json::from_value(params)?;
                documents.remove(params.text_document.uri.as_str());
            }
            (None, "exit") => return Ok(()),
            (None, _) => {
                let _ = params;
            }
        }
    }
}