pinel 0.8.0

A lightweight editor built with rust
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

/// Find and Replace - In-editor find and replace with case-sensitive toggle,
/// match navigation, replace-one, and replace-all.
/// Ported from pinel's hotkey/find_replace.rs, adapted for iced.
#[derive(Default)]
pub struct FindReplace {
    pub open: bool,
    pub find_text: String,
    pub replace_text: String,
    pub case_sensitive: bool,
    pub match_count: usize,
    pub current_match: usize,
    pub matches: Vec<usize>,
}

/// Provides implementation types for the Find and Replace modal
///
/// # Arguments
///
/// - `&mut self` (`undefined`) - Provides the attrubutes for `Self`.
impl FindReplace {
    pub fn toggle(&mut self) {
        self.open = !self.open;
        if self.open {
            self.match_count = 0;
            self.current_match = 0;
            self.matches.clear();
        }
    }

    pub fn close(&mut self) {
        self.open = false;
    }

    /// Uses string matching to find matches within scope.
    ///
    /// # Arguments
    ///
    /// - `&mut self` (`undefined`) - Provides the parameters and arguments for `Self`.
    /// - `text` (`&str`) - Text to search and find matches over.
    ///
    /// # Returns
    ///
    /// - `Vec<usize>` - All of the possible matches based on the string matching algorithm.
    pub fn find_matches(&mut self, text: &str) -> Vec<usize> {
        if self.find_text.is_empty() {
            self.matches.clear();
            self.match_count = 0;
            return Vec::new();
        }

        let mut found_matches = Vec::new();
        let search_text = if self.case_sensitive {
            text.to_string()
        } else {
            text.to_lowercase()
        };
        let find = if self.case_sensitive {
            self.find_text.clone()
        } else {
            self.find_text.to_lowercase()
        };

        let mut start = 0;
        while let Some(pos) = search_text[start..].find(&find) {
            found_matches.push(start + pos);
            start += pos + 1;
        }

        self.matches = found_matches.clone();
        self.match_count = found_matches.len();
        found_matches
    }

    pub fn go_to_next_match(&mut self) {
        if !self.matches.is_empty() {
            self.current_match = (self.current_match + 1) % self.matches.len();
        }
    }

    pub fn go_to_prev_match(&mut self) {
        if !self.matches.is_empty() {
            if self.current_match == 0 {
                self.current_match = self.matches.len() - 1;
            } else {
                self.current_match -= 1;
            }
        }
    }

    pub fn replace_next(&mut self, text: &mut String) -> bool {
        if self.matches.is_empty() || self.current_match >= self.matches.len() {
            return false;
        }

        let pos = self.matches[self.current_match];
        let end = pos + self.find_text.len();
        text.replace_range(pos..end, &self.replace_text);

        self.find_matches(text);

        if self.current_match >= self.matches.len() && !self.matches.is_empty() {
            self.current_match = self.matches.len() - 1;
        }

        true
    }

    pub fn replace_all(&mut self, text: &mut String) -> usize {
        if self.find_text.is_empty() {
            return 0;
        }

        let count = self.matches.len();

        for &pos in self.matches.iter().rev() {
            let end = pos + self.find_text.len();
            text.replace_range(pos..end, &self.replace_text);
        }

        self.matches.clear();
        self.match_count = 0;
        self.current_match = 0;

        count
    }

    pub fn match_status(&self) -> String {
        if self.find_text.is_empty() {
            String::new()
        } else if self.match_count > 0 {
            format!("{} of {}", self.current_match + 1, self.match_count)
        } else {
            "No matches".to_string()
        }
    }
}