repgrep 0.16.1

An interactive command line replacer for `ripgrep`.
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

use ratatui::style::{Color, Style};
use ratatui::text::Span;
use ratatui::widgets::ListState;

#[derive(Debug)]
pub struct AppListState {
    /// The selected "item" in the list of items received from rg
    selected_item: usize,
    /// The selected submatch of the selected "item"
    selected_submatch: usize,
    /// The position of the indicator on the left of the main list view
    indicator: ListState,
    /// The position of the start of the visible window in the main list view.
    /// We only send the visible lines to the renderer for performance reasons, and
    /// this represents the beginning of the visible window.
    window_start: usize,
}

impl AppListState {
    pub fn new() -> AppListState {
        let mut list_state = ListState::default();
        list_state.select(Some(0));
        AppListState {
            selected_item: 0,
            selected_submatch: 0,
            indicator: list_state,
            window_start: 0,
        }
    }

    pub fn indicator_mut(&mut self) -> &mut ListState {
        &mut self.indicator
    }

    pub fn set_indicator_pos(&mut self, idx: usize) {
        self.indicator.select(Some(idx));
    }

    pub fn window_start(&self) -> usize {
        self.window_start
    }

    pub fn set_window_start(&mut self, start: usize) {
        self.window_start = start;
    }

    pub fn selected_item(&self) -> usize {
        self.selected_item
    }

    pub fn selected_submatch(&self) -> usize {
        self.selected_submatch
    }

    pub fn set_selected_item(&mut self, idx: usize) {
        self.selected_item = idx
    }

    pub fn set_selected_submatch(&mut self, idx: usize) {
        self.selected_submatch = idx
    }
}

#[derive(Debug)]
pub enum AppState {
    Running,
    Cancelled,
    Complete,
}

/// Describes the various states that `App` can be in.
#[derive(Debug, Eq, PartialEq)]
pub enum AppUiState {
    /// Show the help text and keybindings.
    Help,
    /// The main matches list: select or deselect the found matches.
    SelectMatches,
    /// Prompt the user for the replacement text.
    /// (ReplacementText, CharPosition)
    InputReplacement(String, usize),
    /// Ask the user to confirm the replacement.
    /// (ReplacementText, CharPosition)
    ConfirmReplacement(String, usize),
}

impl AppUiState {
    pub fn is_replacing(&self) -> bool {
        matches!(
            self,
            AppUiState::InputReplacement(_, _) | AppUiState::ConfirmReplacement(_, _)
        )
    }

    pub fn user_replacement_text(&self) -> Option<&str> {
        match &self {
            AppUiState::InputReplacement(replacement, _)
            | AppUiState::ConfirmReplacement(replacement, _) => Some(replacement.as_str()),
            _ => None,
        }
    }

    /// Represent the `AppUiState` as a `Text`.
    /// This is displayed as the "mode" in the stats line.
    pub fn to_span(&self) -> Span {
        let style = Style::default().fg(Color::Black);
        match self {
            AppUiState::Help => Span::styled(" HELP ", style.bg(Color::Green)),
            AppUiState::SelectMatches => Span::styled(" SELECT ", style.bg(Color::Cyan)),
            AppUiState::InputReplacement(_, _) => Span::styled(" REPLACE ", style.bg(Color::White)),
            AppUiState::ConfirmReplacement(_, _) => Span::styled(" CONFIRM ", style.bg(Color::Red)),
        }
    }
}

/// A small struct to manage scrolling the text in the help view.
#[derive(Debug)]
pub struct HelpTextState {
    pub pos: usize,
    pub max: usize,
    help_text: &'static str,
}

impl HelpTextState {
    pub fn new(help_text: &'static str) -> HelpTextState {
        HelpTextState {
            pos: 0,
            max: help_text.lines().count() - 1,
            help_text,
        }
    }

    pub fn incr(&mut self) {
        if self.pos < self.max {
            self.pos += 1;
        }
    }

    pub fn decr(&mut self) {
        self.pos = self.pos.saturating_sub(1);
    }

    pub fn text(&self, num_lines: usize) -> String {
        self.help_text
            .lines()
            .skip(self.pos)
            .take(num_lines)
            .collect::<Vec<_>>()
            .join("\n")
    }
}