use std::collections::BTreeMap;
#[cfg(test)]
mod tests;
pub fn block_end(lines: &[String], start: usize) -> Option<usize> {
let mut depth = 0usize;
for c in lines.get(start)?.chars() {
match c {
'{' => depth += 1,
'}' => depth = depth.saturating_sub(1),
_ => {}
}
}
if depth == 0 {
return None;
}
for (y, line) in lines.iter().enumerate().skip(start + 1) {
for c in line.chars() {
match c {
'{' => depth += 1,
'}' => {
depth -= 1;
if depth == 0 {
return Some(y);
}
}
_ => {}
}
}
}
None
}
pub fn enclosing_block(lines: &[String], y: usize) -> Option<(usize, usize)> {
(0..y.min(lines.len()))
.rev()
.find_map(|start| match block_end(lines, start) {
Some(end) if end >= y => Some((start, end)),
_ => None,
})
}
#[derive(Default)]
pub struct Folds {
ranges: BTreeMap<usize, usize>,
}
impl Folds {
pub fn fold(&mut self, start: usize, end: usize) {
if end > start {
self.ranges.insert(start, end);
}
}
pub fn unfold(&mut self, y: usize) -> bool {
self.ranges.remove(&y).is_some()
}
pub fn reveal(&mut self, y: usize) {
self.ranges.retain(|start, end| !(*start < y && y <= *end));
}
pub fn end_of(&self, y: usize) -> Option<usize> {
self.ranges.get(&y).copied()
}
pub fn header_of(&self, y: usize) -> usize {
self.ranges
.iter()
.find(|(start, end)| **start < y && y <= **end)
.map_or(y, |(start, _)| *start)
}
pub fn next_visible(&self, y: usize, len: usize) -> Option<usize> {
let next = self.end_of(y).unwrap_or(y) + 1;
(next < len).then_some(next)
}
pub fn prev_visible(&self, y: usize) -> Option<usize> {
y.checked_sub(1).map(|above| self.header_of(above))
}
pub fn rows_between(&self, from: usize, to: usize) -> usize {
let mut rows = 0;
let mut y = from;
while y < to {
y = self.end_of(y).unwrap_or(y) + 1;
rows += 1;
}
rows
}
pub fn shift_after(&mut self, y: usize, delta: isize) {
let shift = |line: usize| (line as isize + delta) as usize;
self.ranges = std::mem::take(&mut self.ranges)
.into_iter()
.map(|(start, end)| {
if start > y {
(shift(start), shift(end))
} else {
(start, end)
}
})
.collect();
}
}