prview 0.4.0

PR Review & Artifact Generator - cross-language PR analysis tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Checks panel - displays check execution status and results.

use ratatui::prelude::*;
use ratatui::widgets::{Block, Borders, List, ListItem, Paragraph, Wrap};

use crate::tui::types::{CheckLifecycle, TuiState};

/// Draw the checks panel
pub fn draw(f: &mut Frame, state: &TuiState, area: Rect) {
    // Split into list and detail areas
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Percentage(50), // Check list
            Constraint::Percentage(50), // Selected check output
        ])
        .split(area);

    draw_check_list(f, state, chunks[0]);
    draw_check_output(f, state, chunks[1]);
}

/// Draw the list of checks with their status
fn draw_check_list(f: &mut Frame, state: &TuiState, area: Rect) {
    let entries = &state.checks_state.entries;

    if entries.is_empty() {
        let empty = Paragraph::new("No checks configured. Press [r] to run analysis.")
            .style(Style::default().fg(Color::DarkGray))
            .block(
                Block::default()
                    .borders(Borders::ALL)
                    .border_style(Style::default().fg(Color::Cyan))
                    .title(" Checks "),
            );
        f.render_widget(empty, area);
        return;
    }

    let items: Vec<ListItem> = entries
        .iter()
        .enumerate()
        .map(|(i, entry)| {
            let is_selected = i == state.checks_state.selected;

            // Status icon with color
            let (icon, icon_color) = match entry.status {
                CheckLifecycle::Pending => ("○", Color::DarkGray),
                CheckLifecycle::Running => ("◐", Color::Yellow),
                CheckLifecycle::Completed => ("●", Color::Green),
                CheckLifecycle::Warned => ("⚠", Color::Yellow),
                CheckLifecycle::Failed => ("✗", Color::Red),
                CheckLifecycle::Skipped => ("○", Color::DarkGray),
                CheckLifecycle::Cached => ("●", Color::Blue),
            };

            // Duration display
            let duration = entry
                .duration
                .map(|d| format!("{:.1}s", d.as_secs_f32()))
                .unwrap_or_else(|| "-".to_string());

            // Status label
            let status_label = match entry.status {
                CheckLifecycle::Pending => "pending",
                CheckLifecycle::Running => "running",
                CheckLifecycle::Completed => "passed",
                CheckLifecycle::Warned => "warnings",
                CheckLifecycle::Failed => "failed",
                CheckLifecycle::Skipped => "skipped",
                CheckLifecycle::Cached => "cached",
            };

            let line = Line::from(vec![
                Span::raw(if is_selected { "▶ " } else { "  " }),
                Span::styled(icon, Style::default().fg(icon_color)),
                Span::raw(" "),
                Span::styled(
                    format!("{:<15}", entry.name),
                    Style::default().fg(if is_selected {
                        Color::Cyan
                    } else {
                        Color::White
                    }),
                ),
                Span::styled(
                    format!("[{}]", status_label),
                    Style::default().fg(icon_color),
                ),
                Span::raw("  "),
                Span::styled(duration, Style::default().fg(Color::DarkGray)),
            ]);

            ListItem::new(line)
        })
        .collect();

    let list = List::new(items).block(
        Block::default()
            .borders(Borders::ALL)
            .border_style(Style::default().fg(Color::Cyan))
            .title(format!(
                " Checks ({}/{}) ",
                entries
                    .iter()
                    .filter(|e| e.status == CheckLifecycle::Completed
                        || e.status == CheckLifecycle::Cached)
                    .count(),
                entries.len()
            )),
    );

    f.render_widget(list, area);
}

/// Draw the output of the selected check
fn draw_check_output(f: &mut Frame, state: &TuiState, area: Rect) {
    let entries = &state.checks_state.entries;

    let (title, content) = if entries.is_empty() {
        (
            " Output ".to_string(),
            "Select a check to view output.".to_string(),
        )
    } else if let Some(entry) = entries.get(state.checks_state.selected) {
        let title = format!(" {} Output ", entry.name);
        let content = if entry.output.is_empty() {
            match entry.status {
                CheckLifecycle::Pending => "Check has not run yet.".to_string(),
                CheckLifecycle::Running => "Check is running...".to_string(),
                CheckLifecycle::Skipped => "Check was skipped.".to_string(),
                _ => "No output available.".to_string(),
            }
        } else {
            entry.output.clone()
        };
        (title, content)
    } else {
        (" Output ".to_string(), "No check selected.".to_string())
    };

    let paragraph = Paragraph::new(content)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::DarkGray))
                .title(title),
        )
        .wrap(Wrap { trim: false })
        .style(Style::default().fg(Color::White));

    f.render_widget(paragraph, area);
}