qlue-ls 2.8.0

A language server for SPARQL
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

//! LSP message framing for stdin input.
//!
//! The Language Server Protocol uses a simple framing format: each message is preceded
//! by HTTP-style headers, with `Content-Length` indicating the message body size.
//!
//! # Key Types
//!
//! - [`StdioMessages`]: An iterator that yields complete LSP messages from stdin
//!
//! # Protocol Format
//!
//! ```text
//! Content-Length: 123\r\n
//! \r\n
//! {"jsonrpc": "2.0", ...}
//! ```
//!
//! The iterator handles reading headers, parsing `Content-Length`, and buffering
//! exactly the right number of bytes for each message body.
//!
//! # Related Modules
//!
//! - [`crate::main`]: Uses this to read messages in server mode
//! - [`crate::server::lsp::rpc`]: Deserializes the JSON-RPC message content

use std::io::{self, BufReader, Read};

pub(super) struct StdioMessages {
    bytes: std::io::Bytes<BufReader<std::io::Stdin>>,
    buffer: Vec<u8>,
}

impl StdioMessages {
    pub(super) fn new() -> Self {
        let stdin = io::stdin();
        let reader = BufReader::new(stdin);
        let bytes = reader.bytes();
        Self {
            bytes,
            buffer: vec![],
        }
    }

    fn read_next_message(&mut self) -> Option<String> {
        loop {
            match self.bytes.next()? {
                Ok(byte) => {
                    self.buffer.push(byte);
                }
                Err(error) => {
                    tracing::error!("Error while reading byte: {}", error);
                    return None;
                }
            }
            // NOTE:: Wait for HEADER to end.
            if self.buffer.ends_with(b"\r\n\r\n") {
                let cl_slice = self
                    .buffer
                    .get(16..(self.buffer.len() - 4))
                    .expect("Header does not have a 'Content-Length: '");
                let cl_string =
                    String::from_utf8(cl_slice.to_vec().clone()).expect("Invalid UTF-8 data");
                let content_length: u32 =
                    cl_string.parse().expect("Failed to parse Content-Length");
                self.buffer.clear();
                // NOTE: READ next x bytes
                for ele in 0..content_length {
                    match self.bytes.next()? {
                        Ok(byte) => {
                            self.buffer.push(byte);
                        }
                        Err(err) => {
                            tracing::error!(
                                "Error {} occured while reading byte {} of {}, clearing buffer",
                                err,
                                ele,
                                content_length
                            );
                            self.buffer.clear();
                            break;
                        }
                    }
                }
                let message = String::from_utf8(self.buffer.clone()).ok()?;
                self.buffer.clear();
                return Some(message);
            }
        }
    }
}

impl Iterator for StdioMessages {
    type Item = String;

    fn next(&mut self) -> Option<Self::Item> {
        self.read_next_message()
    }
}