Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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 @@ where
table_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 @@ where
self.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 @@ where
Tag::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 @@ where
self.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.rs
index 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.rs
index 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_stack
diff --git a/codex-rs/tui/src/markdown_render_tests.rs b/codex-rs/tui/src/markdown_render_tests.rs
index 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()