use std::collections::BTreeMap;
#[cfg(test)]
mod tests;
pub struct Blocks {
ends: Vec<Option<usize>>,
}
impl Blocks {
pub fn by_braces(lines: &[String]) -> Self {
let mut ends = vec![None; lines.len()];
let mut open: Vec<usize> = Vec::new();
for (y, line) in lines.iter().enumerate() {
for c in line.chars() {
match c {
'{' => open.push(y),
'}' => {
if let Some(start) = open.pop() {
if start < y {
ends[start] = Some(y);
}
}
}
_ => {}
}
}
}
Self { ends }
}
pub fn by_indent(lines: &[String]) -> Self {
let mut ends = vec![None; lines.len()];
let mut open: Vec<(usize, usize)> = Vec::new();
let mut last_text_line = 0;
for (y, line) in lines.iter().enumerate() {
if line.trim().is_empty() {
continue;
}
let indent = line.chars().take_while(|c| c.is_whitespace()).count();
while let Some(&(start, start_indent)) = open.last() {
if start_indent < indent {
break;
}
open.pop();
if last_text_line > start {
ends[start] = Some(last_text_line);
}
}
open.push((y, indent));
last_text_line = y;
}
for (start, _) in open {
if last_text_line > start {
ends[start] = Some(last_text_line);
}
}
Self { ends }
}
pub fn end(&self, y: usize) -> Option<usize> {
self.ends.get(y).copied().flatten()
}
pub fn enclosing(&self, y: usize) -> Option<(usize, usize)> {
(0..y.min(self.ends.len()))
.rev()
.find_map(|start| match self.end(start) {
Some(end) if end >= y => Some((start, end)),
_ => None,
})
}
pub fn top_level(&self) -> Vec<(usize, usize)> {
let mut blocks = Vec::new();
let mut y = 0;
while y < self.ends.len() {
match self.end(y) {
Some(end) => {
blocks.push((y, end));
y = end + 1;
}
None => y += 1,
}
}
blocks
}
}
#[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 clear(&mut self) {
self.ranges.clear();
}
pub fn is_empty(&self) -> bool {
self.ranges.is_empty()
}
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();
}
}