tij 0.4.16

Text-mode interface for Jujutsu - a TUI for jj version control
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

//! Rendering for ResolveView

use ratatui::{
    Frame,
    layout::Rect,
    style::{Color, Modifier, Style, Stylize},
    text::{Line, Span},
    widgets::Paragraph,
};

use crate::model::Notification;
use crate::ui::{components, theme};

use super::ResolveView;

impl ResolveView {
    /// Render the resolve view
    pub fn render(&self, frame: &mut Frame, area: Rect, notification: Option<&Notification>) {
        let title = Line::from(format!(" Conflicts ({} files) ", self.file_count()))
            .bold()
            .red()
            .centered();

        // Build notification for title bar
        let title_width = title.width();
        let available_for_notif = area.width.saturating_sub(title_width as u16 + 4) as usize;
        let notif_line = notification
            .filter(|n| !n.is_expired())
            .map(|n| components::build_notification_title(n, Some(available_for_notif)))
            .filter(|line| !line.spans.is_empty());

        let block = components::bordered_block_with_notification(title, notif_line);

        if self.is_empty() {
            let paragraph = components::empty_state("All conflicts resolved!", None).block(block);
            frame.render_widget(paragraph, area);
            return;
        }

        let inner_height = area.height.saturating_sub(2) as usize;
        if inner_height == 0 {
            return;
        }

        // Build content lines
        let mut lines: Vec<Line> = Vec::new();

        // Header: change info
        let header = if self.is_working_copy {
            Line::from(vec![
                Span::styled("  Working copy: ", Style::default().fg(Color::Gray)),
                Span::styled(
                    self.revision.clone(),
                    Style::default()
                        .fg(Color::Cyan)
                        .add_modifier(Modifier::BOLD),
                ),
            ])
        } else {
            Line::from(vec![
                Span::styled("  Change: ", Style::default().fg(Color::Gray)),
                Span::styled(
                    self.revision.clone(),
                    Style::default()
                        .fg(Color::Cyan)
                        .add_modifier(Modifier::BOLD),
                ),
                Span::styled(" (not working copy)", Style::default().fg(Color::Yellow)),
            ])
        };
        lines.push(header);

        // Warning for non-@ changes
        if !self.is_working_copy {
            lines.push(Line::from(Span::styled(
                "  ⚠ External merge tool not available for non-@ changes",
                Style::default().fg(Color::Yellow),
            )));
        }

        lines.push(Line::from("")); // blank line

        // File list
        let header_lines = lines.len();
        let available_for_files = inner_height.saturating_sub(header_lines + 1); // +1 for hint line
        let scroll_offset = self.calculate_scroll_offset(available_for_files);

        for (idx, file) in self.files.iter().enumerate().skip(scroll_offset) {
            if lines.len() >= inner_height.saturating_sub(1) {
                break;
            }

            let is_selected = idx == self.selected_index;
            let marker = if is_selected { "> " } else { "  " };

            let mut spans = vec![
                Span::raw(format!("  {}", marker)),
                Span::styled(
                    "C ",
                    Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
                ),
            ];

            // Extract N-sided count for compact display
            let sided = if let Some(n) = file.description.split('-').next() {
                format!("({}-sided)", n)
            } else {
                format!("({})", file.description)
            };

            spans.push(Span::raw(format!("{:<30} ", file.path)));
            spans.push(Span::styled(sided, Style::default().fg(Color::DarkGray)));

            let mut line = Line::from(spans);

            if is_selected {
                line = line.style(
                    Style::default()
                        .fg(theme::selection::FG)
                        .bg(theme::selection::BG)
                        .add_modifier(Modifier::BOLD),
                );
            }

            lines.push(line);
        }

        // Hint line at bottom
        let hint = if self.is_working_copy {
            Line::from(Span::styled(
                "  Hint: You can continue working with conflicts. Resolve later with 'X'.",
                Style::default().fg(Color::DarkGray),
            ))
        } else {
            Line::from(Span::styled(
                "  Hint: Only :ours / :theirs available for non-working-copy changes.",
                Style::default().fg(Color::DarkGray),
            ))
        };
        // Pad to push hint to bottom if there's space
        while lines.len() < inner_height.saturating_sub(1) {
            lines.push(Line::from(""));
        }
        lines.push(hint);

        let paragraph = Paragraph::new(lines).block(block);
        frame.render_widget(paragraph, area);
    }
}