add gantt compact display mode via yaml frontmatter (#55)

Author: smitbarmase

src/ir.rs

@@ -412,6 +412,7 @@ pub struct Graph {
     pub gantt_tasks: Vec<GanttTask>,
     pub gantt_title: Option<String>,
     pub gantt_sections: Vec<String>,
+    pub gantt_display_mode: Option<String>,
     pub journey_title: Option<String>,
     pub gitgraph: GitGraphData,
     pub class_defs: HashMap<String, NodeStyle>,
@@ -554,6 +555,7 @@ impl Graph {
             gantt_tasks: Vec::new(),
             gantt_title: None,
             gantt_sections: Vec::new(),
+            gantt_display_mode: None,
             journey_title: None,
             gitgraph: GitGraphData::default(),
             class_defs: HashMap::new(),

src/layout/gantt.rs

@@ -252,6 +252,12 @@ pub(super) fn compute_gantt_layout(graph: &Graph, theme: &Theme, config: &Layout
         ticks.push(GanttTick { x, label });
     }
 
+    let compact = graph
+        .gantt_display_mode
+        .as_deref()
+        .map(|m| m.eq_ignore_ascii_case("compact"))
+        .unwrap_or(false);
+
     let palette = gantt_palette(theme);
     let section_palette = gantt_section_palette(theme, &graph.gantt_sections);
     let mut current_section: Option<String> = None;
@@ -260,13 +266,18 @@ pub(super) fn compute_gantt_layout(graph: &Graph, theme: &Theme, config: &Layout
     let mut tasks: Vec<GanttTaskLayout> = Vec::new();
     let mut y = chart_y;
 
+    // Compact mode: pack non-overlapping tasks into the same row.
+    // Each lane is y_position, end_time
+    let mut lanes: Vec<(f32, f32)> = Vec::new();
+
     for (idx, (label, start, duration, status, section)) in computed.iter().enumerate() {
         if section != &current_section {
             if let Some(sec) = section.as_ref() {
                 if let Some(prev_idx) = current_section_idx {
                     let height = (y - sections[prev_idx].y).max(row_height);
                     sections[prev_idx].height = height;
                 }
+                lanes.clear();
                 let base_color = section_palette
                     .get(sec)
                     .cloned()
@@ -284,6 +295,7 @@ pub(super) fn compute_gantt_layout(graph: &Graph, theme: &Theme, config: &Layout
                 let height = (y - sections[prev_idx].y).max(row_height);
                 sections[prev_idx].height = height;
                 current_section_idx = None;
+                lanes.clear();
             }
             current_section = section.clone();
         }
@@ -304,18 +316,35 @@ pub(super) fn compute_gantt_layout(graph: &Graph, theme: &Theme, config: &Layout
         };
         let color = gantt_task_color(*status, &base_color, &palette[0]);
 
+        let task_end = start + duration;
+        let task_y = if compact {
+            if let Some(lane) = lanes.iter_mut().find(|(_, end)| *start >= *end) {
+                let ly = lane.0;
+                lane.1 = task_end;
+                ly
+            } else {
+                let ly = y;
+                lanes.push((ly, task_end));
+                y += row_height;
+                ly
+            }
+        } else {
+            let ly = y;
+            y += row_height;
+            ly
+        };
+
         tasks.push(GanttTaskLayout {
             label: measure_label(label, theme, config),
             x: bar_x,
-            y,
+            y: task_y,
             width: bar_width,
             height: row_height,
             color,
             start: *start,
             duration: *duration,
             status: *status,
         });
-        y += row_height;
     }
     if let Some(prev_idx) = current_section_idx {
         let height = (y - sections[prev_idx].y).max(row_height);
@@ -339,8 +368,15 @@ pub(super) fn compute_gantt_layout(graph: &Graph, theme: &Theme, config: &Layout
         .fold(0.0_f32, f32::max);
     let axis_pad = row_height * 0.9 + theme.font_size;
     let height = y + padding + axis_pad;
-    let width = (chart_x + chart_width + padding)
-        .max(chart_x + chart_width + max_tick_half_width + padding * 0.4);
+    let label_overflow = if compact {
+        padding + task_label_width
+    } else {
+        0.0
+    };
+    let right_padding = (max_tick_half_width + padding * 0.4)
+        .max(label_overflow)
+        .max(padding);
+    let width = chart_x + chart_width + right_padding;
 
     Layout {
         kind: graph.kind,
@@ -366,8 +402,113 @@ pub(super) fn compute_gantt_layout(graph: &Graph, theme: &Theme, config: &Layout
             task_label_width,
             title_y: chart_y - row_height * 0.6,
             ticks,
+            compact,
         }),
         width,
         height,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::ir::{DiagramKind, GanttStatus, GanttTask, Graph};
+    use crate::layout::LayoutConfig;
+    use crate::layout::types::DiagramData;
+    use crate::theme::Theme;
+
+    use super::compute_gantt_layout;
+
+    fn make_graph(display_mode: Option<&str>, tasks: Vec<GanttTask>) -> Graph {
+        let mut graph = Graph::new();
+        graph.kind = DiagramKind::Gantt;
+        graph.gantt_display_mode = display_mode.map(|s| s.to_string());
+        let mut sections = Vec::new();
+        for t in &tasks {
+            if let Some(sec) = &t.section {
+                if !sections.contains(sec) {
+                    sections.push(sec.clone());
+                }
+            }
+        }
+        graph.gantt_sections = sections;
+        graph.gantt_tasks = tasks;
+        graph
+    }
+
+    fn task(id: &str, section: &str, start: &str, dur: &str) -> GanttTask {
+        GanttTask {
+            id: id.to_string(),
+            label: id.to_string(),
+            start: Some(start.to_string()),
+            duration: Some(dur.to_string()),
+            after: None,
+            section: Some(section.to_string()),
+            status: None,
+        }
+    }
+
+    fn milestone(id: &str, section: &str, start: &str) -> GanttTask {
+        GanttTask {
+            id: id.to_string(),
+            label: id.to_string(),
+            start: Some(start.to_string()),
+            duration: Some("0d".to_string()),
+            after: None,
+            section: Some(section.to_string()),
+            status: Some(GanttStatus::Milestone),
+        }
+    }
+
+    fn extract_task_ys(graph: &Graph) -> Vec<f32> {
+        let theme = Theme::modern();
+        let config = LayoutConfig::default();
+        let layout = compute_gantt_layout(graph, &theme, &config);
+        match &layout.diagram {
+            DiagramData::Gantt(g) => g.tasks.iter().map(|t| t.y).collect(),
+            _ => panic!("expected Gantt layout"),
+        }
+    }
+
+    #[test]
+    fn compact_non_overlapping_tasks_share_row() {
+        let graph = make_graph(
+            Some("compact"),
+            vec![
+                milestone("m1", "MacOS", "2025-09-01"),
+                milestone("m2", "MacOS", "2026-09-01"),
+                milestone("m3", "MacOS", "2027-09-01"),
+            ],
+        );
+        let ys = extract_task_ys(&graph);
+        assert_eq!(ys[0], ys[1], "m1 and m2 should share a row");
+        assert_eq!(ys[1], ys[2], "m2 and m3 should share a row");
+    }
+
+    #[test]
+    fn compact_overlapping_tasks_get_separate_rows() {
+        let graph = make_graph(
+            Some("compact"),
+            vec![
+                task("hw", "support", "2025-09-01", "1y"),
+                task("sw", "support", "2025-09-01", "2y"),
+            ],
+        );
+        let ys = extract_task_ys(&graph);
+        assert_ne!(ys[0], ys[1], "overlapping tasks must be on different rows");
+    }
+
+    #[test]
+    fn non_compact_always_separate_rows() {
+        let graph = make_graph(
+            None,
+            vec![
+                milestone("m1", "MacOS", "2025-09-01"),
+                milestone("m2", "MacOS", "2026-09-01"),
+                milestone("m3", "MacOS", "2027-09-01"),
+            ],
+        );
+        let ys = extract_task_ys(&graph);
+        assert_ne!(ys[0], ys[1]);
+        assert_ne!(ys[1], ys[2]);
+    }
+}

src/layout/types.rs

@@ -585,6 +585,7 @@ pub struct GanttLayout {
     pub task_label_width: f32,
     pub title_y: f32,
     pub ticks: Vec<GanttTick>,
+    pub compact: bool,
 }
 
 #[derive(Debug, Clone)]

src/parser.rs

@@ -84,11 +84,19 @@ pub fn parse_mermaid(input: &str) -> Result<ParseOutput> {
 }
 
 fn detect_diagram_kind(input: &str) -> DiagramKind {
+    let mut in_frontmatter = false;
     for raw_line in input.lines() {
         let trimmed_line = raw_line.trim();
         if trimmed_line.is_empty() {
             continue;
         }
+        if trimmed_line == "---" {
+            in_frontmatter = !in_frontmatter;
+            continue;
+        }
+        if in_frontmatter {
+            continue;
+        }
         if trimmed_line.starts_with("%%") {
             continue;
         }
@@ -176,12 +184,20 @@ fn detect_diagram_kind(input: &str) -> DiagramKind {
 fn preprocess_input(input: &str) -> Result<(Vec<String>, Option<serde_json::Value>)> {
     let mut init_config: Option<serde_json::Value> = None;
     let mut lines = Vec::new();
+    let mut in_frontmatter = false;
 
     for raw_line in input.lines() {
         let trimmed_line = raw_line.trim();
         if trimmed_line.is_empty() {
             continue;
         }
+        if trimmed_line == "---" {
+            in_frontmatter = !in_frontmatter;
+            continue;
+        }
+        if in_frontmatter {
+            continue;
+        }
         if let Some(caps) = INIT_RE.captures(trimmed_line) {
             if let Some(json_str) = caps.get(1).map(|m| m.as_str()) {
                 if let Ok(value) = serde_json::from_str::<serde_json::Value>(json_str) {
@@ -2072,12 +2088,39 @@ fn parse_timeline_diagram(input: &str) -> Result<ParseOutput> {
     Ok(ParseOutput { graph, init_config })
 }
 
+fn extract_frontmatter_value(input: &str, key: &str) -> Option<String> {
+    let mut in_frontmatter = false;
+    for line in input.lines() {
+        let trimmed = line.trim();
+        if trimmed == "---" {
+            if in_frontmatter {
+                return None;
+            }
+            in_frontmatter = true;
+            continue;
+        }
+        if in_frontmatter {
+            if let Some((k, v)) = trimmed.split_once(':') {
+                if k.trim() == key {
+                    let val = v.trim().to_string();
+                    if !val.is_empty() {
+                        return Some(val);
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
 fn parse_gantt_diagram(input: &str) -> Result<ParseOutput> {
     let mut graph = Graph::new();
     graph.kind = DiagramKind::Gantt;
     graph.direction = Direction::LeftRight;
     let (lines, init_config) = preprocess_input(input)?;
 
+    graph.gantt_display_mode = extract_frontmatter_value(input, "displayMode");
+
     let mut current_section: Option<usize> = None;
     let mut current_section_name: Option<String> = None;
     let mut last_task: Option<String> = None;
@@ -6396,6 +6439,22 @@ A["foo & bar"] & B --> C"#;
         assert_eq!(parsed.graph.edges.len(), 1);
     }
 
+    #[test]
+    fn parse_gantt_frontmatter_display_mode() {
+        let input = "---\ndisplayMode: compact\n---\ngantt\n  title Plan\n  section Alpha\n  Task A : a1, 2020-01-01, 5d";
+        let parsed = parse_mermaid(input).unwrap();
+        assert_eq!(parsed.graph.kind, DiagramKind::Gantt);
+        assert_eq!(parsed.graph.gantt_display_mode.as_deref(), Some("compact"),);
+        assert!(
+            !parsed
+                .graph
+                .gantt_tasks
+                .iter()
+                .any(|t| t.label.contains("displayMode")),
+            "displayMode should not appear as a task"
+        );
+    }
+
     #[test]
     fn parse_requirement_basic() {
         let input = "requirementDiagram\n  requirement req1 {\n    id: 1\n    text: Login\n  }\n  requirement req2\n  req1 - satisfies -> req2";

src/render.rs

@@ -3388,14 +3388,27 @@ fn render_gantt(
         }
         // Task label
         if !label_rendered_inside {
+            // In compact mode, place next to the element to avoid
+            // overlapping labels when multiple tasks share a row.
+            let (label_x, anchor) = if layout.compact {
+                let gap = theme.font_size * 0.4;
+                if matches!(task.status, Some(crate::ir::GanttStatus::Milestone)) {
+                    let size = bar_height * 0.6;
+                    (task.x + size + gap, "start")
+                } else {
+                    (task.x + task.width + gap, "start")
+                }
+            } else {
+                (layout.task_label_x, "start")
+            };
             svg.push_str(&text_block_svg_with_font_size(
-                layout.task_label_x,
+                label_x,
                 row_center,
                 &task.label,
                 theme,
                 config,
                 task_font,
-                "start",
+                anchor,
                 Some(theme.primary_text_color.as_str()),
                 false,
             ));