sync-lsp 0.1.0

A synchronous LSP library for servers
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

//! implements the `window/showMessageRequest` request.
//!
//! # Usage
//! This request may be used to query the user for a choice.
//! The result can be retrieved using [`Server::on_show_message_response`] and therefore
//! [`Connection::show_message_request`] won't block the current thread.

use std::collections::HashMap;
use std::mem::replace;
use serde::{Serialize, Deserialize};
use crate::{Connection, Server, TypeProvider};
use crate::connection::{RpcConnection, Callback};

use super::MessageType;

pub(super) struct ShowMessageRequest<T: TypeProvider> {
    callback: Callback<Server<T>>
}

/// This Item is beeing sent along every show message request.
#[derive(Serialize, Deserialize, Debug)]
#[serde(bound = "")]
pub struct MessageActionItem<T: Default> {
    /// The title of the message action which will be shown to the user.
    pub title: String,
    /// This field is preserved and will be sent back in the response.
    /// It's type can be specified using the [`TypeProvider`] trait.
    #[serde(skip)]
    #[serde(default)]
    pub data: T
}

#[derive(Serialize)]
#[serde(bound = "")]
struct ShowMessageRequestParams<T: Default> {
    #[serde(rename = "type")]
    r#type: MessageType,
    message: String,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    actions: Vec<MessageActionItem<T>>
}

impl<T: TypeProvider> Connection<T> {

    /// This request will [trigger a query](self) to the user.
    /// 
    /// # Arguments
    /// * `r#type` - The type of message to show.
    /// * `message` - The message to show.
    /// * `actions` - The actions to show.
    /// * `result` - A boolean indicating whether the request was sent.
    
    pub fn show_message_request(&mut self, r#type: MessageType, message: String, mut actions: Vec<MessageActionItem<T::ShowMessageRequestData>>) -> bool {
        self.request(
            ShowMessageRequest::<T>::METHOD,
            {
                let mut hashmap = HashMap::new();
                for action in actions.iter_mut() {
                    let data = replace(&mut action.data, Default::default());
                    hashmap.insert(action.title.clone(), data);
                }
                hashmap
            },
            ShowMessageRequestParams {
                r#type,
                message,
                actions
            }
        )
    }
}

impl<T: TypeProvider> Server<T> {

    /// Set the response handler for [showing a message request](self)
    ///
    /// # Argument
    /// * `callback` - A callback which is called with the following parameters if the result of a query is received:
    ///     * The server instance receiving the response.
    ///     * A tag of type [`TypeProvider::ShowMessageRequestData`] that was passed to the request.
    
    pub fn on_show_message_response(&mut self, callback: fn(&mut Server<T>, MessageActionItem<T::ShowMessageRequestData>)) {
        self.window.show_message_request.callback = Callback::response(move |connection, mut tag: HashMap<String, T::ShowMessageRequestData>, params: Option<MessageActionItem<T::ShowMessageRequestData>>| {
            if let Some(mut action) = params {
                action.data = tag.remove(action.title.as_str()).unwrap_or_default();
                callback(connection, action)
            }
        })
    }
}

impl<T: TypeProvider> Default for ShowMessageRequest<T> {
    fn default() -> Self {
        Self {
            callback: Callback::response(|_, _: HashMap<String, T::ShowMessageRequestData>, _: Option<MessageActionItem<T::ShowMessageRequestData>>| {})
        }
    }
}

impl<T: TypeProvider> ShowMessageRequest<T> {
    pub(super) const METHOD: &'static str = "window/showMessageRequest";

    pub(crate) fn callback(&self) -> Callback<Server<T>> {
        self.callback.clone()
    }
}