feat: width-aware markdown table rendering with text wrapping (v0.7.2)

Tables in markdown preview now auto-fit to the terminal pane width.
Column widths are proportionally distributed and cell text wraps on
word boundaries instead of extending beyond the visible area.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: alankyshum

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "semantic-diff"
-version = "0.7.1"
+version = "0.7.2"
 edition = "2021"
 description = "A terminal diff viewer with AI-powered semantic grouping (Claude CLI / Copilot)"
 license = "MIT"

Cargo.toml

@@ -20,7 +20,8 @@ pub enum PreviewBlock {
 }
 
 /// Parse markdown source and return a list of preview blocks.
-pub fn parse_markdown(source: &str) -> Vec<PreviewBlock> {
+/// `width` is the available terminal columns for text wrapping (0 = no limit).
+pub fn parse_markdown(source: &str, width: u16) -> Vec<PreviewBlock> {
     let mut opts = Options::empty();
     opts.insert(Options::ENABLE_TABLES);
     opts.insert(Options::ENABLE_STRIKETHROUGH);
@@ -31,7 +32,7 @@ pub fn parse_markdown(source: &str) -> Vec<PreviewBlock> {
 
     let mut blocks: Vec<PreviewBlock> = Vec::new();
     let mut lines: Vec<Line<'static>> = Vec::new();
-    let mut renderer = MarkdownRenderer::new();
+    let mut renderer = MarkdownRenderer::new(width);
 
     let mut i = 0;
     while i < events.len() {
@@ -90,6 +91,8 @@ struct MarkdownRenderer {
     /// Whether we're inside a code block (non-mermaid)
     in_code_block: bool,
     code_block_lang: String,
+    /// Available terminal width for table wrapping
+    pane_width: u16,
 }
 
 struct TableState {
@@ -100,7 +103,7 @@ struct TableState {
 }
 
 impl MarkdownRenderer {
-    fn new() -> Self {
+    fn new(pane_width: u16) -> Self {
         Self {
             style_stack: vec![Style::default()],
             current_spans: Vec::new(),
@@ -110,6 +113,7 @@ impl MarkdownRenderer {
             table_state: None,
             in_code_block: false,
             code_block_lang: String::new(),
+            pane_width,
         }
     }
 
@@ -354,7 +358,7 @@ impl MarkdownRenderer {
             }
             Event::End(TagEnd::Table) => {
                 if let Some(table) = self.table_state.take() {
-                    lines.extend(render_table(&table.rows));
+                    lines.extend(render_table(&table.rows, self.pane_width));
                     lines.push(Line::raw(""));
                 }
             }
@@ -416,22 +420,32 @@ impl MarkdownRenderer {
 }
 
 /// Render a table as aligned ratatui Lines with box-drawing characters.
-fn render_table(rows: &[Vec<String>]) -> Vec<Line<'static>> {
+/// Columns are constrained to fit within `pane_width` and cell text wraps.
+fn render_table(rows: &[Vec<String>], pane_width: u16) -> Vec<Line<'static>> {
     if rows.is_empty() {
         return Vec::new();
     }
 
-    // Calculate column widths
     let num_cols = rows.iter().map(|r| r.len()).max().unwrap_or(0);
-    let mut col_widths = vec![0usize; num_cols];
+    if num_cols == 0 {
+        return Vec::new();
+    }
+
+    // Natural (max content) width per column
+    let mut natural_widths = vec![0usize; num_cols];
     for row in rows {
         for (i, cell) in row.iter().enumerate() {
             if i < num_cols {
-                col_widths[i] = col_widths[i].max(cell.len());
+                natural_widths[i] = natural_widths[i].max(cell.len());
             }
         }
     }
 
+    // Compute column widths that fit within pane_width.
+    // Overhead: 2 (indent) + num_cols+1 (border chars │) + num_cols*2 (padding spaces)
+    let overhead = 2 + (num_cols + 1) + num_cols * 2;
+    let col_widths = fit_column_widths(&natural_widths, pane_width as usize, overhead);
+
     let mut lines = Vec::new();
     let header_style = Style::default()
         .fg(Color::Cyan)
@@ -454,13 +468,33 @@ fn render_table(rows: &[Vec<String>]) -> Vec<Line<'static>> {
         let is_header = ri == 0;
         let style = if is_header { header_style } else { cell_style };
 
-        let mut spans = vec![Span::styled("  │".to_string(), border_style)];
+        // Word-wrap each cell into its column width
+        let mut wrapped_cells: Vec<Vec<String>> = Vec::new();
+        let mut max_lines = 1usize;
         for (ci, width) in col_widths.iter().enumerate() {
             let cell = row.get(ci).map(|s| s.as_str()).unwrap_or("");
-            spans.push(Span::styled(format!(" {cell:<width$} ", width = width), style));
-            spans.push(Span::styled("│".to_string(), border_style));
+            let cell_lines = wrap_text(cell, *width);
+            max_lines = max_lines.max(cell_lines.len());
+            wrapped_cells.push(cell_lines);
+        }
+
+        // Emit one Line per wrapped row
+        for line_idx in 0..max_lines {
+            let mut spans = vec![Span::styled("  │".to_string(), border_style)];
+            for (ci, width) in col_widths.iter().enumerate() {
+                let text = wrapped_cells
+                    .get(ci)
+                    .and_then(|wc| wc.get(line_idx))
+                    .map(|s| s.as_str())
+                    .unwrap_or("");
+                spans.push(Span::styled(
+                    format!(" {text:<width$} ", width = width),
+                    style,
+                ));
+                spans.push(Span::styled("│".to_string(), border_style));
+            }
+            lines.push(Line::from(spans));
         }
-        lines.push(Line::from(spans));
 
         // Separator after header row
         if is_header {
@@ -490,28 +524,131 @@ fn render_table(rows: &[Vec<String>]) -> Vec<Line<'static>> {
     lines
 }
 
+/// Compute column widths that fit within `total_width` (including `overhead`).
+/// Distributes available space proportionally to natural widths. Minimum column width is 4.
+fn fit_column_widths(natural: &[usize], total_width: usize, overhead: usize) -> Vec<usize> {
+    let available = total_width.saturating_sub(overhead);
+    let mut widths: Vec<usize> = natural.iter().map(|&w| w.max(1)).collect();
+    let min_col = 4usize;
+
+    let total_natural: usize = widths.iter().sum();
+    if total_natural <= available || available == 0 {
+        return widths;
+    }
+
+    // Proportionally distribute available space
+    let mut remaining = available;
+    for (i, w) in widths.iter_mut().enumerate() {
+        if i == natural.len() - 1 {
+            // Last column gets whatever is left
+            *w = remaining.max(min_col);
+        } else {
+            let proportion = (natural[i] as f64) / (total_natural as f64);
+            let alloc = (proportion * available as f64).floor() as usize;
+            *w = alloc.max(min_col);
+            remaining = remaining.saturating_sub(*w);
+        }
+    }
+
+    widths
+}
+
+/// Wrap text to fit within `width` characters, breaking on word boundaries.
+fn wrap_text(text: &str, width: usize) -> Vec<String> {
+    if width == 0 || text.len() <= width {
+        return vec![text.to_string()];
+    }
+
+    let mut lines = Vec::new();
+    let mut current = String::new();
+
+    for word in text.split_whitespace() {
+        if current.is_empty() {
+            if word.len() > width {
+                // Hard-break long words
+                let mut remaining = word;
+                while remaining.len() > width {
+                    lines.push(remaining[..width].to_string());
+                    remaining = &remaining[width..];
+                }
+                current = remaining.to_string();
+            } else {
+                current = word.to_string();
+            }
+        } else if current.len() + 1 + word.len() <= width {
+            current.push(' ');
+            current.push_str(word);
+        } else {
+            lines.push(current);
+            if word.len() > width {
+                let mut remaining = word;
+                while remaining.len() > width {
+                    lines.push(remaining[..width].to_string());
+                    remaining = &remaining[width..];
+                }
+                current = remaining.to_string();
+            } else {
+                current = word.to_string();
+            }
+        }
+    }
+    if !current.is_empty() {
+        lines.push(current);
+    }
+    if lines.is_empty() {
+        lines.push(String::new());
+    }
+
+    lines
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_heading_parsing() {
-        let blocks = parse_markdown("# Hello\n\nSome text");
+        let blocks = parse_markdown("# Hello\n\nSome text", 80);
         assert!(!blocks.is_empty());
     }
 
     #[test]
     fn test_mermaid_extraction() {
         let md = "# Diagram\n\n```mermaid\ngraph TD\n    A-->B\n```\n\nAfter.";
-        let blocks = parse_markdown(md);
+        let blocks = parse_markdown(md, 80);
         let has_mermaid = blocks.iter().any(|b| matches!(b, PreviewBlock::Mermaid(_)));
         assert!(has_mermaid, "Should extract mermaid block");
     }
 
     #[test]
     fn test_table_rendering() {
         let md = "| A | B |\n|---|---|\n| 1 | 2 |\n| 3 | 4 |";
-        let blocks = parse_markdown(md);
+        let blocks = parse_markdown(md, 80);
         assert!(!blocks.is_empty());
     }
+
+    #[test]
+    fn test_table_wraps_in_narrow_width() {
+        let rows = vec![
+            vec!["Name".to_string(), "Description".to_string()],
+            vec!["Alice".to_string(), "A very long description that should wrap".to_string()],
+            vec!["Bob".to_string(), "Short".to_string()],
+        ];
+        let lines = render_table(&rows, 40);
+        for line in &lines {
+            // Use char count, not byte count (box-drawing chars are multi-byte)
+            let total: usize = line.spans.iter().map(|s| s.content.chars().count()).sum();
+            assert!(total <= 40, "Line width {total} exceeds pane width 40: {:?}",
+                line.spans.iter().map(|s| s.content.as_ref()).collect::<Vec<_>>());
+        }
+        // The wrapped table should have more lines than a 3-row table normally would
+        assert!(lines.len() > 5, "Table should have wrapped rows, got {} lines", lines.len());
+    }
+
+    #[test]
+    fn test_wrap_text() {
+        assert_eq!(wrap_text("hello world", 5), vec!["hello", "world"]);
+        assert_eq!(wrap_text("hi", 10), vec!["hi"]);
+        assert_eq!(wrap_text("abcdefghij", 4), vec!["abcd", "efgh", "ij"]);
+    }
 }

src/preview/markdown.rs

@@ -42,7 +42,7 @@ pub fn render_preview(app: &App, frame: &mut Frame, area: Rect) -> Vec<PendingIm
         }
     };
 
-    let blocks = crate::preview::markdown::parse_markdown(&file_content);
+    let blocks = crate::preview::markdown::parse_markdown(&file_content, area.width);
     let can_render_images = matches!(app.image_support, ImageSupport::Supported(_));
 
     // Build segments
@@ -274,7 +274,8 @@ impl Segment {
                 lines
                     .iter()
                     .map(|line| {
-                        let char_width: usize = line.spans.iter().map(|s| s.content.len()).sum();
+                        let char_width: usize =
+                            line.spans.iter().map(|s| s.content.chars().count()).sum();
                         if char_width == 0 {
                             1
                         } else {

src/ui/preview_view.rs

@@ -343,7 +343,7 @@ graph TD
 [Link](https://example.com)
 "#;
 
-    let blocks = parse_markdown(md);
+    let blocks = parse_markdown(md, 120);
     assert!(!blocks.is_empty(), "Should produce blocks");
 
     let has_text = blocks.iter().any(|b| matches!(b, PreviewBlock::Text(_)));