Skip to main content

minus/
line_navigation.rs

1use crate::{PagerState, error::MinusError, minus_core::utils::term};
2mod deferred;
3use crossterm::{
4    cursor,
5    event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
6    terminal::{Clear, ClearType},
7};
8pub use deferred::SourceViewRenderer;
9use std::io::Write;
10use std::time::Duration;
11
12/// Source-line maps and optional alternate source-numbered pager content.
13#[derive(Clone, Debug, Eq, PartialEq)]
14pub struct LineNavigation {
15    pub(crate) toc: Vec<crate::TocEntry>,
16    /// Source line for each logical line in the normal pager content.
17    display_source_lines: Vec<Option<usize>>,
18    source_view: SourceView,
19}
20
21#[derive(Clone, Debug, Eq, PartialEq)]
22enum SourceView {
23    Current,
24    Deferred(deferred::DeferredSource),
25    Alternate {
26        text: String,
27        source_lines: Vec<Option<usize>>,
28    },
29}
30
31pub struct LineNavigationSession {
32    original_upper_mark: usize,
33    original_left_mark: usize,
34    target: Option<usize>,
35    prompt_origin: Option<usize>,
36}
37
38impl LineNavigation {
39    /// Prepares alternate source-numbered content without changing the active view.
40    ///
41    /// # Errors
42    ///
43    /// Returns the deferred renderer's layout error without replacing the source view.
44    pub fn prepare_source_view(&mut self) -> Result<(), crate::PromptError> {
45        if let SourceView::Deferred(source) = &self.source_view {
46            let (text, source_lines) = (source.0)().map_err(crate::PromptError::Layout)?;
47            self.source_view = SourceView::Alternate { text, source_lines };
48        }
49        Ok(())
50    }
51
52    /// Creates navigation data that prepares source-numbered content on first use.
53    #[must_use]
54    pub fn deferred(
55        display_source_lines: Vec<Option<usize>>,
56        renderer: SourceViewRenderer,
57    ) -> Self {
58        Self {
59            toc: Vec::new(),
60            display_source_lines,
61            source_view: SourceView::Deferred(deferred::DeferredSource(renderer)),
62        }
63    }
64
65    /// Creates line-navigation data with alternate source-numbered content.
66    ///
67    /// Both maps contain one entry per logical line. `None` marks lines that do not
68    /// originate from a source line, such as inserted spacing.
69    #[must_use]
70    pub fn new(
71        source_text: impl Into<String>,
72        display_source_lines: Vec<Option<usize>>,
73        navigation_source_lines: Vec<Option<usize>>,
74    ) -> Self {
75        Self {
76            toc: Vec::new(),
77            display_source_lines,
78            source_view: SourceView::Alternate {
79                text: source_text.into(),
80                source_lines: navigation_source_lines,
81            },
82        }
83    }
84
85    /// Creates navigation data when the pager content is already source-numbered.
86    #[must_use]
87    pub const fn from_current(source_lines: Vec<Option<usize>>) -> Self {
88        Self {
89            toc: Vec::new(),
90            display_source_lines: source_lines,
91            source_view: SourceView::Current,
92        }
93    }
94
95    /// Attaches an outline whose targets are one-based source lines.
96    #[must_use]
97    pub fn with_toc(mut self, entries: Vec<crate::TocEntry>) -> Self {
98        self.toc = entries;
99        self
100    }
101}
102
103#[derive(Clone, Copy)]
104pub enum LineInputResult {
105    Cancelled,
106    Confirmed(Option<usize>),
107}
108
109impl PagerState {
110    pub(crate) fn replace_mapped_text(
111        &mut self,
112        text: String,
113        navigation: Option<LineNavigation>,
114    ) -> Result<(), crate::PromptError> {
115        let navigation_view = self.line_navigation_session.is_some();
116        let anchor = self.source_line_map(navigation_view).and_then(|map| {
117            let index = self.lines_to_row_map.row_to_line(self.upper_mark)?;
118            (0..=index).rev().find_map(|i| {
119                Some((
120                    map.get(i).copied().flatten()?,
121                    self.upper_mark
122                        .saturating_sub(*self.lines_to_row_map.get(i)?),
123                ))
124            })
125        });
126        self.line_navigation_session = None;
127        self.toc.reset_position();
128        self.line_navigation = navigation;
129        self.screen.orig_text = text;
130        self.screen.line_count = self.screen.orig_text.lines().count();
131        self.clear_selection();
132        self.left_mark = 0;
133        self.reformat_display()?;
134        if let Some((source, offset)) = anchor
135            && let Some(row) = self.row_for_source_line(source, false)
136        {
137            let next = (row + 1..self.screen.formatted_lines.len())
138                .find(|&i| {
139                    self.source_line_at_row(i, false)
140                        .is_some_and(|line| line != source)
141                })
142                .unwrap_or(self.screen.formatted_lines.len());
143            self.upper_mark = row.saturating_add(offset.min(next.saturating_sub(row + 1)));
144        }
145        self.upper_mark = self.upper_mark.min(self.max_upper_mark());
146        self.format_prompt()
147    }
148
149    /// Returns whether source-line navigation is configured.
150    #[must_use]
151    pub(crate) const fn line_navigation_available(&self) -> bool {
152        if self.line_navigation.is_none() {
153            return false;
154        }
155        match &self.line_navigation_session {
156            Some(session) => session.prompt_origin.is_none(),
157            None => true,
158        }
159    }
160
161    /// Returns whether a source-line target is active.
162    #[must_use]
163    pub(crate) const fn line_navigation_is_active(&self) -> bool {
164        match &self.line_navigation_session {
165            Some(session) => session.prompt_origin.is_none() && session.target.is_some(),
166            None => false,
167        }
168    }
169
170    #[must_use]
171    pub(crate) const fn line_navigation_position(&self) -> Option<usize> {
172        match &self.line_navigation_session {
173            Some(session) if session.prompt_origin.is_none() => session.target,
174            _ => None,
175        }
176    }
177
178    pub(crate) fn begin_line_navigation(&mut self) -> Result<bool, crate::PromptError> {
179        if !self.line_navigation_available() {
180            return Ok(false);
181        }
182
183        if self.line_navigation_session.is_none() {
184            let navigation = self
185                .line_navigation
186                .as_mut()
187                .expect("available line navigation requires configured content");
188            navigation.prepare_source_view()?;
189            let original_upper_mark = self.upper_mark;
190            let original_left_mark = self.left_mark;
191            let uses_alternate_view = self.line_navigation.as_ref().is_some_and(|navigation| {
192                matches!(navigation.source_view, SourceView::Alternate { .. })
193            });
194            let visible_source_line = self.source_line_at_row(self.upper_mark, false);
195            if uses_alternate_view {
196                self.left_mark = 0;
197                self.swap_line_navigation_text();
198                self.reformat_display()?;
199                self.upper_mark = visible_source_line
200                    .and_then(|line| self.row_for_source_line(line, true))
201                    .unwrap_or(self.upper_mark)
202                    .min(self.max_upper_mark());
203            }
204            self.line_navigation_session = Some(LineNavigationSession {
205                original_upper_mark,
206                original_left_mark,
207                target: None,
208                prompt_origin: None,
209            });
210        }
211
212        if let Some(session) = self.line_navigation_session.as_mut() {
213            session.prompt_origin = Some(self.upper_mark);
214        }
215        self.selection = None;
216        self.selection_anchor = None;
217        Ok(true)
218    }
219
220    pub(crate) fn configure_line_navigation(
221        &mut self,
222        navigation: Option<LineNavigation>,
223    ) -> Result<(), crate::PromptError> {
224        self.exit_line_navigation()?;
225        self.line_navigation = navigation;
226        Ok(())
227    }
228
229    pub(crate) fn finish_line_navigation(
230        &mut self,
231        source_line: Option<usize>,
232    ) -> Result<bool, crate::PromptError> {
233        let Some(prompt_upper_mark) = self
234            .line_navigation_session
235            .as_mut()
236            .and_then(|session| session.prompt_origin.take())
237        else {
238            return Ok(false);
239        };
240
241        if let Some(source_line) = source_line
242            && let Some(target_row) = self.row_for_source_line(source_line, true)
243        {
244            self.upper_mark = target_row;
245            if let Some(session) = self.line_navigation_session.as_mut() {
246                session.target = Some(source_line);
247            }
248            return Ok(true);
249        }
250
251        if self
252            .line_navigation_session
253            .as_ref()
254            .is_some_and(|session| session.target.is_some())
255        {
256            self.upper_mark = prompt_upper_mark;
257        } else {
258            self.exit_line_navigation()?;
259        }
260        Ok(false)
261    }
262
263    pub(crate) fn exit_line_navigation(&mut self) -> Result<bool, crate::PromptError> {
264        let Some(session) = self.line_navigation_session.take() else {
265            return Ok(false);
266        };
267        let visible_source_line = self.source_line_at_row(self.upper_mark, true);
268
269        let uses_alternate_view = self.line_navigation.as_ref().is_some_and(|navigation| {
270            matches!(navigation.source_view, SourceView::Alternate { .. })
271        });
272        if uses_alternate_view {
273            self.swap_line_navigation_text();
274            self.left_mark = session.original_left_mark;
275            self.reformat_display()?;
276        }
277
278        let source_line = visible_source_line.or(session.target);
279        if let Some(target_row) = source_line.and_then(|line| self.row_for_source_line(line, false))
280        {
281            self.upper_mark = target_row;
282        } else {
283            self.upper_mark = session.original_upper_mark.min(self.max_upper_mark());
284        }
285        Ok(true)
286    }
287
288    pub(crate) fn source_line_is_highlighted(&self, absolute_row: usize) -> bool {
289        if !self.line_navigation_is_active() {
290            return false;
291        }
292        self.source_line_at_row(absolute_row, true) == self.line_navigation_position()
293    }
294
295    fn swap_line_navigation_text(&mut self) {
296        let navigation = self
297            .line_navigation
298            .as_mut()
299            .expect("line navigation session requires configured content");
300        let SourceView::Alternate { text, .. } = &mut navigation.source_view else {
301            unreachable!("swapped line navigation session requires alternate content");
302        };
303        std::mem::swap(&mut self.screen.orig_text, text);
304        self.screen.line_count = self.screen.orig_text.lines().count();
305    }
306
307    fn source_line_at_row(&self, row: usize, navigation_view: bool) -> Option<usize> {
308        let line_map = self.source_line_map(navigation_view)?;
309        let line_index = self.lines_to_row_map.row_to_line(row)?;
310        line_map.get(line_index).copied().flatten()
311    }
312
313    pub(crate) fn row_for_source_line(
314        &self,
315        source_line: usize,
316        navigation_view: bool,
317    ) -> Option<usize> {
318        let line_map = self.source_line_map(navigation_view)?;
319        let line_index = line_map
320            .iter()
321            .position(|line| *line == Some(source_line))?;
322        self.lines_to_row_map.get(line_index).copied()
323    }
324
325    fn source_line_map(&self, navigation_view: bool) -> Option<&[Option<usize>]> {
326        let navigation = self.line_navigation.as_ref()?;
327        match (&navigation.source_view, navigation_view) {
328            (SourceView::Alternate { source_lines, .. }, true) => Some(source_lines),
329            _ => Some(&navigation.display_source_lines),
330        }
331    }
332}
333
334pub fn fetch_line_number(
335    out: &mut impl Write,
336    pager: &PagerState,
337) -> Result<LineInputResult, MinusError> {
338    let mut input = String::new();
339    draw_input(out, pager, &input)?;
340
341    let result = loop {
342        if !event::poll(Duration::from_millis(100))
343            .map_err(|error| MinusError::HandleEvent(error.into()))?
344        {
345            continue;
346        }
347        let event = event::read().map_err(|error| MinusError::HandleEvent(error.into()))?;
348        let Event::Key(key) = event else {
349            continue;
350        };
351        if key.kind != KeyEventKind::Press || key.modifiers != KeyModifiers::NONE {
352            continue;
353        }
354        match key.code {
355            KeyCode::Esc => break LineInputResult::Cancelled,
356            KeyCode::Enter => {
357                let line = input.parse::<usize>().ok().filter(|line| *line > 0);
358                break LineInputResult::Confirmed(line);
359            }
360            KeyCode::Backspace => {
361                input.pop();
362                draw_input(out, pager, &input)?;
363            }
364            KeyCode::Char(character) if character.is_ascii_digit() => {
365                input.push(character);
366                draw_input(out, pager, &input)?;
367            }
368            _ => {}
369        }
370    };
371
372    let row = prompt_row(pager)?;
373    term::move_cursor(out, 0, row, false)?;
374    write!(out, "{}{}", Clear(ClearType::CurrentLine), cursor::Hide)?;
375    out.flush()?;
376    Ok(result)
377}
378
379fn draw_input(out: &mut impl Write, pager: &PagerState, input: &str) -> Result<(), MinusError> {
380    let row = prompt_row(pager)?;
381    let column = input
382        .chars()
383        .count()
384        .saturating_add(1)
385        .try_into()
386        .unwrap_or(u16::MAX);
387    term::move_cursor(out, 0, row, false)?;
388    write!(
389        out,
390        "{}:{input}{}",
391        Clear(ClearType::CurrentLine),
392        cursor::Show
393    )?;
394    term::move_cursor(out, column, row, false)?;
395    out.flush().map_err(MinusError::Draw)
396}
397
398fn prompt_row(pager: &PagerState) -> Result<u16, MinusError> {
399    pager
400        .prompt_row()
401        .try_into()
402        .map_err(|_| MinusError::Conversion)
403}
404
405#[cfg(test)]
406mod tests;