1 files changed, 118 insertions, 0 deletions
diff --git a/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs b/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs
new file mode 100644
index 000000000..27e4f1cbc
--- /dev/null
+++ b/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs
@@ -0,0 +1,118 @@
+//! A minimal example LSP server that can only respond to the `gotoDefinition` request. To use
+//! this example, execute it and then send an `initialize` request.
+//!
+//! ```no_run
+//! Content-Length: 85
+//!
+//! {"jsonrpc": "2.0", "method": "initialize", "id": 1, "params": {"capabilities": {}}}
+//! ```
+//!
+//! This will respond with a server respose. Then send it a `initialized` notification which will
+//! have no response.
+//!
+//! ```no_run
+//! Content-Length: 59
+//!
+//! {"jsonrpc": "2.0", "method": "initialized", "params": {}}
+//! ```
+//!
+//! Once these two are sent, then we enter the main loop of the server. The only request this
+//! example can handle is `gotoDefinition`:
+//!
+//! ```no_run
+//! Content-Length: 159
+//!
+//! {"jsonrpc": "2.0", "method": "textDocument/definition", "id": 2, "params": {"textDocument": {"uri": "file://temp"}, "position": {"line": 1, "character": 1}}}
+//! ```
+//!
+//! To finish up without errors, send a shutdown request:
+//!
+//! ```no_run
+//! Content-Length: 67
+//!
+//! {"jsonrpc": "2.0", "method": "shutdown", "id": 3, "params": null}
+//! ```
+//!
+//! The server will exit the main loop and finally we send a `shutdown` notification to stop
+//! the server.
+//!
+//! ```
+//! Content-Length: 54
+//!
+//! {"jsonrpc": "2.0", "method": "exit", "params": null}
+//! ```
+use crossbeam_channel::{Sender, Receiver};
+use lsp_types::{
+    ServerCapabilities, InitializeParams,
+    request::{GotoDefinition, GotoDefinitionResponse},
+};
+use log::info;
+use gen_lsp_server::{
+    run_server, stdio_transport, handle_shutdown, RawMessage, RawResponse, RawRequest,
+};
+fn main() -> Result<(), failure::Error> {
+    // Set up logging. Because `stdio_transport` gets a lock on stdout and stdin, we must have
+    // our logging only write out to stderr.
+    flexi_logger::Logger::with_str("info").start().unwrap();
+    info!("starting generic LSP server");
+    // Create the transport. Includes the stdio (stdin and stdout) versions but this could
+    // also be implemented to use sockets or HTTP.
+    let (receiver, sender, io_threads) = stdio_transport();
+    // Run the server and wait for the two threads to end (typically by trigger LSP Exit event).
+    run_server(ServerCapabilities::default(), receiver, sender, main_loop)?;
+    io_threads.join()?;
+    // Shut down gracefully.
+    info!("shutting down server");
+    Ok(())
+}
+fn main_loop(
+    _params: InitializeParams,
+    receiver: &Receiver<RawMessage>,
+    sender: &Sender<RawMessage>,
+) -> Result<(), failure::Error> {
+    info!("starting example main loop");
+    for msg in receiver {
+        info!("got msg: {:?}", msg);
+        match msg {
+            RawMessage::Request(req) => {
+                let req = match log_handle_shutdown(req, sender) {
+                    None => return Ok(()),
+                    Some(req) => req,
+                };
+                info!("got request: {:?}", req);
+                match req.cast::<GotoDefinition>() {
+                    Ok((id, params)) => {
+                        info!("got gotoDefinition request #{}: {:?}", id, params);
+                        let resp = RawResponse::ok::<GotoDefinition>(
+                            id,
+                            &Some(GotoDefinitionResponse::Array(Vec::new())),
+                        );
+                        info!("sending gotoDefinition response: {:?}", resp);
+                        sender.send(RawMessage::Response(resp))?;
+                        continue;
+                    }
+                    Err(req) => req,
+                };
+                // ...
+            }
+            RawMessage::Response(resp) => {
+                info!("got response: {:?}", resp);
+            }
+            RawMessage::Notification(not) => {
+                info!("got notification: {:?}", not);
+            }
+        }
+    }
+    Ok(())
+}
+pub fn log_handle_shutdown(req: RawRequest, sender: &Sender<RawMessage>) -> Option<RawRequest> {
+    info!("handle_shutdown: {:?}", req);
+    handle_shutdown(req, sender)
+}

diff --git a/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs b/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs new file mode 100644 index 000000000..27e4f1cbc --- /dev/null +++ b/crates/gen_lsp_server/examples/02_gen_lsp_server_with_logging.rs
@@ -0,0 +1,118 @@
	1	//! A minimal example LSP server that can only respond to the `gotoDefinition` request. To use
	2	//! this example, execute it and then send an `initialize` request.
	3	//!
	4	//! ```no_run
	5	//! Content-Length: 85
	6	//!
	7	//! {"jsonrpc": "2.0", "method": "initialize", "id": 1, "params": {"capabilities": {}}}
	8	//! ```
	9	//!
	10	//! This will respond with a server respose. Then send it a `initialized` notification which will
	11	//! have no response.
	12	//!
	13	//! ```no_run
	14	//! Content-Length: 59
	15	//!
	16	//! {"jsonrpc": "2.0", "method": "initialized", "params": {}}
	17	//! ```
	18	//!
	19	//! Once these two are sent, then we enter the main loop of the server. The only request this
	20	//! example can handle is `gotoDefinition`:
	21	//!
	22	//! ```no_run
	23	//! Content-Length: 159
	24	//!
	25	//! {"jsonrpc": "2.0", "method": "textDocument/definition", "id": 2, "params": {"textDocument": {"uri": "file://temp"}, "position": {"line": 1, "character": 1}}}
	26	//! ```
	27	//!
	28	//! To finish up without errors, send a shutdown request:
	29	//!
	30	//! ```no_run
	31	//! Content-Length: 67
	32	//!
	33	//! {"jsonrpc": "2.0", "method": "shutdown", "id": 3, "params": null}
	34	//! ```
	35	//!
	36	//! The server will exit the main loop and finally we send a `shutdown` notification to stop
	37	//! the server.
	38	//!
	39	//! ```
	40	//! Content-Length: 54
	41	//!
	42	//! {"jsonrpc": "2.0", "method": "exit", "params": null}
	43	//! ```
	44
	45	use crossbeam_channel::{Sender, Receiver};
	46	use lsp_types::{
	47	ServerCapabilities, InitializeParams,
	48	request::{GotoDefinition, GotoDefinitionResponse},
	49	};
	50	use log::info;
	51	use gen_lsp_server::{
	52	run_server, stdio_transport, handle_shutdown, RawMessage, RawResponse, RawRequest,
	53	};
	54
	55	fn main() -> Result<(), failure::Error> {
	56	// Set up logging. Because `stdio_transport` gets a lock on stdout and stdin, we must have
	57	// our logging only write out to stderr.
	58	flexi_logger::Logger::with_str("info").start().unwrap();
	59	info!("starting generic LSP server");
	60
	61	// Create the transport. Includes the stdio (stdin and stdout) versions but this could
	62	// also be implemented to use sockets or HTTP.
	63	let (receiver, sender, io_threads) = stdio_transport();
	64
	65	// Run the server and wait for the two threads to end (typically by trigger LSP Exit event).
	66	run_server(ServerCapabilities::default(), receiver, sender, main_loop)?;
	67	io_threads.join()?;
	68
	69	// Shut down gracefully.
	70	info!("shutting down server");
	71	Ok(())
	72	}
	73
	74	fn main_loop(
	75	_params: InitializeParams,
	76	receiver: &Receiver<RawMessage>,
	77	sender: &Sender<RawMessage>,
	78	) -> Result<(), failure::Error> {
	79	info!("starting example main loop");
	80	for msg in receiver {
	81	info!("got msg: {:?}", msg);
	82	match msg {
	83	RawMessage::Request(req) => {
	84	let req = match log_handle_shutdown(req, sender) {
	85	None => return Ok(()),
	86	Some(req) => req,
	87	};
	88	info!("got request: {:?}", req);
	89	match req.cast::<GotoDefinition>() {
	90	Ok((id, params)) => {
	91	info!("got gotoDefinition request #{}: {:?}", id, params);
	92	let resp = RawResponse::ok::<GotoDefinition>(
	93	id,
	94	&Some(GotoDefinitionResponse::Array(Vec::new())),
	95	);
	96	info!("sending gotoDefinition response: {:?}", resp);
	97	sender.send(RawMessage::Response(resp))?;
	98	continue;
	99	}
	100	Err(req) => req,
	101	};
	102	// ...
	103	}
	104	RawMessage::Response(resp) => {
	105	info!("got response: {:?}", resp);
	106	}
	107	RawMessage::Notification(not) => {
	108	info!("got notification: {:?}", not);
	109	}
	110	}
	111	}
	112	Ok(())
	113	}
	114
	115	pub fn log_handle_shutdown(req: RawRequest, sender: &Sender<RawMessage>) -> Option<RawRequest> {
	116	info!("handle_shutdown: {:?}", req);
	117	handle_shutdown(req, sender)
	118	}