git.iko.soy/helix
on master help sign in
dap: Add RunInTerminal reverse request, support replying to requests
5545f8eBlaž Hrastnik
helix-dap/src/client.rs+39−3
compare with master
unifiedsplit
@@ -1,5 +1,5 @@
1use crate::{
1use crate::{
2− transport::{Payload, Request, Transport},
2+ transport::{Payload, Request, Response, Transport},
3 types::*,
3 types::*,
4 Error, Result, ThreadId,
4 Error, Result, ThreadId,
5};
5};
@@ -29,7 +29,7 @@ use tokio::{
29pub struct Client {
29pub struct Client {
30 id: usize,
30 id: usize,
31 _process: Option<Child>,
31 _process: Option<Child>,
32− server_tx: UnboundedSender<Request>,
32+ server_tx: UnboundedSender<Payload>,
33 request_counter: AtomicU64,
33 request_counter: AtomicU64,
34 pub caps: Option<DebuggerCapabilities>,
34 pub caps: Option<DebuggerCapabilities>,
35 // thread_id -> frames
35 // thread_id -> frames
@@ -234,7 +234,9 @@ impl Client {
234 arguments,
234 arguments,
235 };
235 };
236
236
237+ server_tx
238+ .send(Payload::Request(req))
237− server_tx.send(req).map_err(|e| Error::Other(e.into()))?;
239+ .map_err(|e| Error::Other(e.into()))?;
238
240
239 // TODO: specifiable timeout, delay other calls until initialize success
241 // TODO: specifiable timeout, delay other calls until initialize success
240 timeout(Duration::from_secs(20), callback_rx.recv())
242 timeout(Duration::from_secs(20), callback_rx.recv())
@@ -257,6 +259,40 @@ impl Client {
257 Ok(response)
259 Ok(response)
258 }
260 }
259
261
262+ pub fn reply(
263+ &self,
264+ request_seq: u64,
265+ command: String,
266+ result: core::result::Result<Value, Error>,
267+ ) -> impl Future<Output = Result<()>> {
268+ let server_tx = self.server_tx.clone();
269+
270+ async move {
271+ let response = match result {
272+ Ok(result) => Response {
273+ request_seq,
274+ command,
275+ success: true,
276+ message: None,
277+ body: Some(result),
278+ },
279+ Err(error) => Response {
280+ request_seq,
281+ command,
282+ success: false,
283+ message: Some(error.to_string()),
284+ body: None,
285+ },
286+ };
287+
288+ server_tx
289+ .send(Payload::Response(response))
290+ .map_err(|e| Error::Other(e.into()))?;
291+
292+ Ok(())
293+ }
294+ }
295+
260 pub fn capabilities(&self) -> &DebuggerCapabilities {
296 pub fn capabilities(&self) -> &DebuggerCapabilities {
261 self.caps.as_ref().expect("debugger not yet initialized!")
297 self.caps.as_ref().expect("debugger not yet initialized!")
262 }
298 }
helix-dap/src/transport.rs+10−10
@@ -55,7 +55,7 @@ impl Transport {
55 server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
55 server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
56 server_stderr: Option<Box<dyn AsyncBufRead + Unpin + Send>>,
56 server_stderr: Option<Box<dyn AsyncBufRead + Unpin + Send>>,
57 id: usize,
57 id: usize,
58− ) -> (UnboundedReceiver<Payload>, UnboundedSender<Request>) {
58+ ) -> (UnboundedReceiver<Payload>, UnboundedSender<Payload>) {
59 let (client_tx, rx) = unbounded_channel();
59 let (client_tx, rx) = unbounded_channel();
60 let (tx, client_rx) = unbounded_channel();
60 let (tx, client_rx) = unbounded_channel();
61
61
@@ -140,14 +140,14 @@ impl Transport {
140 async fn send_payload_to_server(
140 async fn send_payload_to_server(
141 &self,
141 &self,
142 server_stdin: &mut Box<dyn AsyncWrite + Unpin + Send>,
142 server_stdin: &mut Box<dyn AsyncWrite + Unpin + Send>,
143− mut req: Request,
143+ mut payload: Payload,
144 ) -> Result<()> {
144 ) -> Result<()> {
145− let back_ch = req.back_ch.take();
146− let seq = req.seq;
147− let json = serde_json::to_string(&Payload::Request(req))?;
145+ if let Payload::Request(request) = &mut payload {
148− if let Some(back) = back_ch {
146+ if let Some(back) = request.back_ch.take() {
149− self.pending_requests.lock().await.insert(seq, back);
147+ self.pending_requests.lock().await.insert(request.seq, back);
148+ }
150 }
149 }
150+ let json = serde_json::to_string(&payload)?;
151 self.send_string_to_server(server_stdin, json).await
151 self.send_string_to_server(server_stdin, json).await
152 }
152 }
153
153
@@ -254,11 +254,11 @@ impl Transport {
254 async fn send(
254 async fn send(
255 transport: Arc<Self>,
255 transport: Arc<Self>,
256 mut server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
256 mut server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
257− mut client_rx: UnboundedReceiver<Request>,
257+ mut client_rx: UnboundedReceiver<Payload>,
258 ) {
258 ) {
259− while let Some(req) = client_rx.recv().await {
259+ while let Some(payload) = client_rx.recv().await {
260 transport
260 transport
261− .send_payload_to_server(&mut server_stdin, req)
261+ .send_payload_to_server(&mut server_stdin, payload)
262 .await
262 .await
263 .unwrap()
263 .unwrap()
264 }
264 }
helix-dap/src/types.rs+29
@@ -1,5 +1,6 @@
1use serde::{Deserialize, Serialize};
1use serde::{Deserialize, Serialize};
2use serde_json::Value;
2use serde_json::Value;
3+use std::collections::HashMap;
3use std::path::PathBuf;
4use std::path::PathBuf;
4
5
5#[derive(
6#[derive(
@@ -541,6 +542,34 @@ pub mod requests {
541 type Result = SetExceptionBreakpointsResponse;
542 type Result = SetExceptionBreakpointsResponse;
542 const COMMAND: &'static str = "setExceptionBreakpoints";
543 const COMMAND: &'static str = "setExceptionBreakpoints";
543 }
544 }
545+
546+ // Reverse Requests
547+
548+ #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
549+ #[serde(rename_all = "camelCase")]
550+ pub struct RunInTerminalResponse {
551+ pub process_id: Option<usize>,
552+ pub shell_process_id: Option<usize>,
553+ }
554+
555+ #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
556+ #[serde(rename_all = "camelCase")]
557+ pub struct RunInTerminalArguments {
558+ pub kind: Option<String>,
559+ pub title: Option<String>,
560+ pub cwd: String,
561+ pub args: Vec<String>,
562+ pub env: Option<HashMap<String, Option<String>>>,
563+ }
564+
565+ #[derive(Debug)]
566+ pub enum RunInTerminal {}
567+
568+ impl Request for RunInTerminal {
569+ type Arguments = RunInTerminalArguments;
570+ type Result = RunInTerminalResponse;
571+ const COMMAND: &'static str = "runInTerminal";
572+ }
544}
573}
545
574
546// Events
575// Events
helix-term/src/application.rs+11−2
@@ -1,5 +1,5 @@
1use helix_core::{merge_toml_values, syntax};
1use helix_core::{merge_toml_values, syntax};
2−use helix_dap::Payload;
2+use helix_dap::{self as dap, Payload, Request};
3use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};
3use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};
4use helix_view::{editor::Breakpoint, theme, Editor};
4use helix_view::{editor::Breakpoint, theme, Editor};
5
5
@@ -468,7 +468,16 @@ impl Application {
468 }
468 }
469 }
469 }
470 Payload::Response(_) => unreachable!(),
470 Payload::Response(_) => unreachable!(),
471− Payload::Request(request) => unimplemented!("{:?}", request),
471+ Payload::Request(request) => match request.command.as_str() {
472+ dap::requests::RunInTerminal::COMMAND => {
473+ let arguments: dap::requests::RunInTerminalArguments =
474+ serde_json::from_value(request.arguments.unwrap_or_default()).unwrap();
475+ // TODO: no unwrap
476+
477+ // TODO: dap reply
478+ }
479+ _ => log::error!("DAP reverse request not implemented: {:?}", request),
480+ },
472 }
481 }
473 self.render();
482 self.render();
474 }
483 }