iced_code_editor/canvas_editor/features/folding/
mod.rs1mod ops;
13
14use std::collections::HashSet;
15
16use crate::buffer::TextBuffer;
17
18use crate::canvas_editor::indent_width;
19
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
25pub struct FoldRegion {
26 pub start_line: usize,
28 pub end_line: usize,
30}
31
32impl FoldRegion {
33 pub fn new(start_line: usize, end_line: usize) -> Self {
40 Self { start_line, end_line }
41 }
42}
43
44pub fn compute_foldable_regions(buffer: &TextBuffer) -> Vec<FoldRegion> {
63 let line_count = buffer.line_count();
64 let indents: Vec<Option<usize>> =
66 (0..line_count).map(|i| indent_width(buffer.line(i))).collect();
67
68 let mut regions: Vec<FoldRegion> = Vec::new();
69 let mut open_regions: Vec<(usize, usize)> = Vec::new();
74 let mut non_blank = indents
75 .iter()
76 .enumerate()
77 .filter_map(|(line, indent)| indent.map(|width| (line, width)))
78 .peekable();
79
80 let mut previous_non_blank = None;
81 while let Some((line, indent)) = non_blank.next() {
82 while open_regions
83 .last()
84 .is_some_and(|(header_indent, _)| *header_indent >= indent)
85 {
86 if let Some((_, region_index)) = open_regions.pop()
87 && let Some(end_line) = previous_non_blank
88 && let Some(region) = regions.get_mut(region_index)
89 {
90 region.end_line = end_line;
91 }
92 }
93
94 if non_blank
95 .peek()
96 .is_some_and(|(_, next_indent)| *next_indent > indent)
97 {
98 let region_index = regions.len();
99 regions.push(FoldRegion::new(line, line));
100 open_regions.push((indent, region_index));
101 }
102
103 previous_non_blank = Some(line);
104 }
105
106 if let Some(end_line) = previous_non_blank {
107 for (_, region_index) in open_regions {
108 if let Some(region) = regions.get_mut(region_index) {
109 region.end_line = end_line;
110 }
111 }
112 }
113
114 regions
115}
116
117pub fn is_fold_header(regions: &[FoldRegion], line: usize) -> bool {
124 regions.binary_search_by_key(&line, |region| region.start_line).is_ok()
125}
126
127pub fn is_line_fold_header(buffer: &TextBuffer, line: usize) -> bool {
133 let Some(header_indent) = indent_width(buffer.line(line)) else {
134 return false;
135 };
136
137 (line.saturating_add(1)..buffer.line_count())
138 .find_map(|next_line| indent_width(buffer.line(next_line)))
139 .is_some_and(|next_indent| next_indent > header_indent)
140}
141
142pub fn hidden_lines(
157 regions: &[FoldRegion],
158 collapsed: &HashSet<usize>,
159) -> HashSet<usize> {
160 let mut hidden = HashSet::new();
161 for region in regions {
162 if collapsed.contains(®ion.start_line) {
163 hidden.extend((region.start_line + 1)..=region.end_line);
164 }
165 }
166 hidden
167}
168
169#[cfg(test)]
170mod tests {
171 use super::*;
172
173 #[test]
174 fn test_no_regions_for_flat_text() {
175 let buffer = TextBuffer::new("a\nb\nc");
176 assert!(compute_foldable_regions(&buffer).is_empty());
177 }
178
179 #[test]
180 fn test_simple_block() {
181 let buffer =
183 TextBuffer::new("fn main() {\n let x = 1;\n let y = 2;\n}");
184 let regions = compute_foldable_regions(&buffer);
185 assert_eq!(regions, vec![FoldRegion::new(0, 2)]);
186 }
187
188 #[test]
189 fn test_nested_blocks() {
190 let buffer = TextBuffer::new(
192 "outer:\n inner:\n deep\n deeper\n after_inner",
193 );
194 let regions = compute_foldable_regions(&buffer);
195 assert_eq!(regions, vec![FoldRegion::new(0, 4), FoldRegion::new(1, 3)]);
196 }
197
198 #[test]
199 fn test_blank_lines_inside_and_trailing() {
200 let buffer =
203 TextBuffer::new("def f():\n a = 1\n\n b = 2\n\ng = 3");
204 let regions = compute_foldable_regions(&buffer);
205 assert_eq!(regions, vec![FoldRegion::new(0, 3)]);
208 }
209
210 #[test]
211 fn test_hidden_lines_single_collapsed() {
212 let regions = vec![FoldRegion::new(0, 2)];
213 let collapsed: HashSet<usize> = [0].into_iter().collect();
214 let hidden = hidden_lines(®ions, &collapsed);
215 assert_eq!(hidden, [1, 2].into_iter().collect());
216 }
217
218 #[test]
219 fn test_hidden_lines_nested_union() {
220 let regions = vec![FoldRegion::new(0, 4), FoldRegion::new(1, 3)];
221 let collapsed: HashSet<usize> = [1].into_iter().collect();
223 assert_eq!(
224 hidden_lines(®ions, &collapsed),
225 [2, 3].into_iter().collect()
226 );
227
228 let collapsed: HashSet<usize> = [0, 1].into_iter().collect();
230 assert_eq!(
231 hidden_lines(®ions, &collapsed),
232 [1, 2, 3, 4].into_iter().collect()
233 );
234 }
235
236 #[test]
237 fn test_hidden_lines_ignores_unknown_collapsed() {
238 let regions = vec![FoldRegion::new(0, 2)];
240 let collapsed: HashSet<usize> = [99].into_iter().collect();
241 assert!(hidden_lines(®ions, &collapsed).is_empty());
242 }
243
244 #[test]
245 fn test_is_fold_header() {
246 let regions = vec![FoldRegion::new(0, 2), FoldRegion::new(5, 7)];
247 assert!(is_fold_header(®ions, 0));
248 assert!(is_fold_header(®ions, 5));
249 assert!(!is_fold_header(®ions, 1));
250 assert!(!is_fold_header(®ions, 3));
251 }
252
253 #[test]
254 fn test_is_line_fold_header_skips_blank_lines() {
255 let buffer = TextBuffer::new("header\n\n body\nsibling");
256 assert!(is_line_fold_header(&buffer, 0));
257 assert!(!is_line_fold_header(&buffer, 1));
258 assert!(!is_line_fold_header(&buffer, 2));
259 }
260}