Lightweight coding agent that runs in your terminal
Rust
Reduce generic code duplication in RPC and Markdown rendering (#47751)
Ahmed Ibrahime0ef5a1a0f64
diff --git a/codex-rs/exec-server/src/rpc.rs b/codex-rs/exec-server/src/rpc.rsindex 35fe69468f..3912632ece 100644--- a/codex-rs/exec-server/src/rpc.rs+++ b/codex-rs/exec-server/src/rpc.rs@@ -653,6 +653,23 @@ impl RpcClient {return Err(RpcCallError::Json(err));}};+ let response = self+ .send_request_and_wait(method, request_id, params, response_rx, call_timeout)+ .await?;+ serde_json::from_value(response).map_err(RpcCallError::Json)+ }++ // Sending and waiting are independent of P and T, so share this future+ // across typed calls. Register and serialize in call_inner in that order:+ // a disconnected client must still take precedence over a serialization error.+ async fn send_request_and_wait(+ &self,+ method: &str,+ request_id: RequestId,+ params: Value,+ response_rx: oneshot::Receiver<RpcCompletion>,+ call_timeout: RpcCallTimeout,+ ) -> Result<Value, RpcCallError> {if self.write_tx.send(JSONRPCMessage::Request(JSONRPCRequest {@@ -695,8 +712,7 @@ impl RpcClient {};let completion = response.map_err(|_| RpcCallError::Closed)?;completion.record_receipt(method);- let response = completion.result?;- serde_json::from_value(response).map_err(RpcCallError::Json)+ completion.result}#[cfg(test)]diff --git a/codex-rs/tui/src/markdown_render.rs b/codex-rs/tui/src/markdown_render.rsindex 2063b11aec..5eeab22f55 100644--- a/codex-rs/tui/src/markdown_render.rs+++ b/codex-rs/tui/src/markdown_render.rs@@ -377,8 +377,10 @@ pub(crate) fn render_markdown_lines_with_width_cwd_and_hidden_link_destinations(input,math.events(Parser::new_ext(&math.markdown, options).into_offset_iter()),));- let mut w = Writer::new(input, parser, width, cwd, is_hidden_link_destination);- w.run();+ let mut w = Writer::new(input, width, cwd, is_hidden_link_destination);+ // Drop the consumed parser before the rendering state, including on unwind.+ let mut parser = parser;+ w.run(&mut parser);w.text}@@ -406,12 +408,10 @@ fn should_render_link_destination(dest_url: &str) -> bool {/// and an optional `TableState` for accumulating table events. The/// `wrap_width` field enables width-aware line wrapping and table column/// allocation; when `None`, lines keep their intrinsic width.-struct Writer<'a, 'policy, I>-where- I: Iterator<Item = (Event<'a>, Range<usize>)>,-{+/// Layout state is independent of the parser so rendering routines are compiled+/// once; event traversal remains statically dispatched over each iterator.+struct Writer<'a, 'policy> {input: &'a str,- iter: I,text: Vec<HyperlinkLine>,styles: MarkdownStyles,inline_styles: Vec<Style>,@@ -443,20 +443,15 @@ wheretable_state: Option<TableState>,}-impl<'a, 'policy, I> Writer<'a, 'policy, I>-where- I: Iterator<Item = (Event<'a>, Range<usize>)>,-{+impl<'a, 'policy> Writer<'a, 'policy> {fn new(input: &'a str,- iter: I,wrap_width: Option<usize>,cwd: Option<&Path>,is_hidden_link_destination: &'policy dyn Fn(&str) -> bool,) -> Self {Self {input,- iter,text: Vec::new(),styles: MarkdownStyles::default(),inline_styles: Vec::new(),@@ -489,17 +484,23 @@ where}}- fn run(&mut self) {- while let Some((ev, range)) = self.iter.next() {- self.handle_event(ev, range);+ fn run<I>(&mut self, iter: &mut I)+ where+ I: Iterator<Item = (Event<'a>, Range<usize>)>,+ {+ while let Some((ev, range)) = iter.next() {+ self.handle_event(ev, range, iter);}self.flush_current_line();}- fn handle_event(&mut self, event: Event<'a>, range: Range<usize>) {+ fn handle_event<I>(&mut self, event: Event<'a>, range: Range<usize>, iter: &mut I)+ where+ I: Iterator<Item = (Event<'a>, Range<usize>)>,+ {self.prepare_for_event(&event);match event {- Event::Start(tag) => self.start_tag(tag, range),+ Event::Start(tag) => self.start_tag(tag, range, iter),Event::End(tag) => self.end_tag(tag, range),Event::Text(text) => {if self.in_code_block {@@ -551,7 +552,10 @@ whereself.push_line(Line::default());}- fn start_tag(&mut self, tag: Tag<'a>, range: Range<usize>) {+ fn start_tag<I>(&mut self, tag: Tag<'a>, range: Range<usize>, iter: &mut I)+ where+ I: Iterator<Item = (Event<'a>, Range<usize>)>,+ {match tag {Tag::Paragraph => self.start_paragraph(),Tag::Heading { level, .. } => self.start_heading(level),@@ -571,7 +575,7 @@ whereTag::List(start) => self.start_list(start),Tag::Item => {self.start_item();- if let Some((next, next_range)) = self.iter.next() {+ if let Some((next, next_range)) = iter.next() {// Recover markers consumed without an event before block content or empty items.let content_start = if matches!(next, Event::End(TagEnd::Item)) {range.end@@ -599,7 +603,7 @@ whereself.push_line(Line::default());}}- self.handle_event(next, next_range);+ self.handle_event(next, next_range, iter);}}Tag::Emphasis => self.push_inline_style(self.styles.emphasis),@@ -2494,7 +2498,6 @@ mod tests {let writer = W::new("",- std::iter::empty(),/*wrap_width*/ Some(80),/*cwd*/ None,&never_hide_link_destination,@@ -2520,7 +2523,7 @@ mod tests {// ---------------------------------------------------------------// Type alias for calling private associated functions on Writer.// ---------------------------------------------------------------- type W<'a> = Writer<'a, 'a, std::iter::Empty<(Event<'a>, Range<usize>)>>;+ type W<'a> = Writer<'a, 'a>;/// Build a single-line `TableCell` from plain text.fn make_cell(text: &str) -> TableCell {diff --git a/codex-rs/tui/src/markdown_render/streaming.rs b/codex-rs/tui/src/markdown_render/streaming.rsindex 739eb49641..e306fa3d40 100644--- a/codex-rs/tui/src/markdown_render/streaming.rs+++ b/codex-rs/tui/src/markdown_render/streaming.rs@@ -65,14 +65,16 @@ pub(crate) fn render_streaming_markdown_lines_with_width_and_cwd(first_is_html: false,mutable_fence_start: None,};- let mut writer = Writer::new(input, parser, width, cwd, is_hidden_link_destination);+ let mut writer = Writer::new(input, width, cwd, is_hidden_link_destination);+ // Drop the consumed parser before the rendering state, including on unwind.+ let mut parser = parser;writer.list_spacing = list_spacing;- writer.run();+ writer.run(&mut parser);StreamingMarkdownRender {lines: writer.text,pending_math_start: math.pending_start,- last_top_level_block_start: (writer.iter.block_count > 1)- .then_some(writer.iter.last_start)+ last_top_level_block_start: (parser.block_count > 1)+ .then_some(parser.last_start).filter(|start| math.pending_start.is_none_or(|pending| *start <= pending)).filter(|start| {!math@@ -81,8 +83,8 @@ pub(crate) fn render_streaming_markdown_lines_with_width_and_cwd(.any(|range| range.start < *start && *start < range.end)}),has_reference_link_definition,- first_top_level_block_is_html: writer.iter.first_is_html,- mutable_fence_start: writer.iter.mutable_fence_start,+ first_top_level_block_is_html: parser.first_is_html,+ mutable_fence_start: parser.mutable_fence_start,}}diff --git a/codex-rs/tui/src/markdown_render/task_lists.rs b/codex-rs/tui/src/markdown_render/task_lists.rsindex 69d91aa4ab..debb5f0adf 100644--- a/codex-rs/tui/src/markdown_render/task_lists.rs+++ b/codex-rs/tui/src/markdown_render/task_lists.rs@@ -2,14 +2,9 @@//! Keep the hanging indent aligned with the task text, including in loose lists.use super::Writer;-use pulldown_cmark::Event;use ratatui::text::Span;-use std::ops::Range;-impl<'a, 'policy, I> Writer<'a, 'policy, I>-where- I: Iterator<Item = (Event<'a>, Range<usize>)>,-{+impl Writer<'_, '_> {pub(super) fn task_list_marker(&mut self, checked: bool) {let Some(context) = self.indent_stackdiff --git a/codex-rs/tui/src/markdown_render_tests.rs b/codex-rs/tui/src/markdown_render_tests.rsindex 1e9371c917..d0c8ab0643 100644--- a/codex-rs/tui/src/markdown_render_tests.rs+++ b/codex-rs/tui/src/markdown_render_tests.rs@@ -751,15 +751,16 @@ fn inline_code_and_file_paths_follow_syntax_theme() {crate::terminal_palette::with_test_default_colors(colors, || {let styles = MarkdownStyles::for_theme(&theme);let code_style = styles.code;+ let parser = pulldown_cmark::Parser::new(markdown).into_offset_iter();let mut writer = super::Writer::new(markdown,- pulldown_cmark::Parser::new(markdown).into_offset_iter(),/*wrap_width*/ Some(24),/*cwd*/ None,&|_| false,);writer.styles = styles;- writer.run();+ let mut parser = parser;+ writer.run(&mut parser);let lines = crate::terminal_hyperlinks::visible_lines(writer.text);let paths = lines.iter()