1use language::{BufferSnapshot, OffsetRangeExt as _, Point};
  2use std::ops::Range;
  3
  4#[cfg(not(test))]
  5const MAX_OUTLINE_ITEM_BODY_SIZE: usize = 512;
  6#[cfg(test)]
  7const MAX_OUTLINE_ITEM_BODY_SIZE: usize = 24;
  8
  9pub fn assemble_excerpt_ranges(
 10    buffer: &BufferSnapshot,
 11    input_ranges: Vec<(Range<Point>, usize)>,
 12) -> Vec<(Range<u32>, usize)> {
 13    let mut input_ranges: Vec<(Range<Point>, usize)> = input_ranges
 14        .into_iter()
 15        .map(|(range, order)| (clip_range_to_lines(&range, false, buffer), order))
 16        .collect();
 17    merge_ranges(&mut input_ranges);
 18
 19    let mut outline_ranges: Vec<(Range<Point>, usize)> = Vec::new();
 20    let outline_items = buffer.outline_items_as_points_containing(0..buffer.len(), false, None);
 21    let mut outline_ix = 0;
 22    for (input_range, input_order) in &mut input_ranges {
 23        while let Some(outline_item) = outline_items.get(outline_ix) {
 24            let item_range = clip_range_to_lines(&outline_item.range, false, buffer);
 25
 26            if item_range.start > input_range.start {
 27                break;
 28            }
 29
 30            if item_range.end > input_range.start {
 31                let body_range = outline_item
 32                    .body_range(buffer)
 33                    .map(|body| clip_range_to_lines(&body, true, buffer))
 34                    .filter(|body_range| {
 35                        body_range.to_offset(buffer).len() > MAX_OUTLINE_ITEM_BODY_SIZE
 36                    });
 37
 38                add_outline_item(
 39                    item_range.clone(),
 40                    body_range.clone(),
 41                    *input_order,
 42                    buffer,
 43                    &mut outline_ranges,
 44                );
 45
 46                if let Some(body_range) = body_range
 47                    && input_range.start < body_range.start
 48                {
 49                    let mut child_outline_ix = outline_ix + 1;
 50                    while let Some(next_outline_item) = outline_items.get(child_outline_ix) {
 51                        if next_outline_item.range.end > body_range.end {
 52                            break;
 53                        }
 54                        if next_outline_item.depth == outline_item.depth + 1 {
 55                            let next_item_range =
 56                                clip_range_to_lines(&next_outline_item.range, false, buffer);
 57
 58                            add_outline_item(
 59                                next_item_range,
 60                                next_outline_item
 61                                    .body_range(buffer)
 62                                    .map(|body| clip_range_to_lines(&body, true, buffer)),
 63                                *input_order,
 64                                buffer,
 65                                &mut outline_ranges,
 66                            );
 67                        }
 68                        child_outline_ix += 1;
 69                    }
 70                }
 71            }
 72
 73            outline_ix += 1;
 74        }
 75    }
 76
 77    input_ranges.extend(outline_ranges);
 78    merge_ranges(&mut input_ranges);
 79
 80    input_ranges
 81        .into_iter()
 82        .map(|(range, order)| (range.start.row..range.end.row, order))
 83        .collect()
 84}
 85
 86fn clip_range_to_lines(
 87    range: &Range<Point>,
 88    inward: bool,
 89    buffer: &BufferSnapshot,
 90) -> Range<Point> {
 91    let mut range = range.clone();
 92    if inward {
 93        if range.start.column > 0 {
 94            range.start.column = buffer.line_len(range.start.row);
 95        }
 96        range.end.column = 0;
 97    } else {
 98        range.start.column = 0;
 99        if range.end.column > 0 {
100            range.end.column = buffer.line_len(range.end.row);
101        }
102    }
103    range
104}
105
106fn add_outline_item(
107    mut item_range: Range<Point>,
108    body_range: Option<Range<Point>>,
109    order: usize,
110    buffer: &BufferSnapshot,
111    outline_ranges: &mut Vec<(Range<Point>, usize)>,
112) {
113    if let Some(mut body_range) = body_range {
114        if body_range.start.column > 0 {
115            body_range.start.column = buffer.line_len(body_range.start.row);
116        }
117        body_range.end.column = 0;
118
119        let head_range = item_range.start..body_range.start;
120        if head_range.start < head_range.end {
121            outline_ranges.push((head_range, order));
122        }
123
124        let tail_range = body_range.end..item_range.end;
125        if tail_range.start < tail_range.end {
126            outline_ranges.push((tail_range, order));
127        }
128    } else {
129        item_range.start.column = 0;
130        item_range.end.column = buffer.line_len(item_range.end.row);
131        outline_ranges.push((item_range, order));
132    }
133}
134
135pub fn merge_ranges(ranges: &mut Vec<(Range<Point>, usize)>) {
136    ranges.sort_unstable_by(|(a, _), (b, _)| a.start.cmp(&b.start).then(b.end.cmp(&a.end)));
137
138    let mut index = 1;
139    while index < ranges.len() {
140        let mut prev_range_end = ranges[index - 1].0.end;
141        if prev_range_end.column > 0 {
142            prev_range_end += Point::new(1, 0);
143        }
144
145        if (prev_range_end + Point::new(1, 0))
146            .cmp(&ranges[index].0.start)
147            .is_ge()
148        {
149            let removed = ranges.remove(index);
150            if removed.0.end.cmp(&ranges[index - 1].0.end).is_gt() {
151                ranges[index - 1].0.end = removed.0.end;
152            }
153            ranges[index - 1].1 = ranges[index - 1].1.min(removed.1);
154        } else {
155            index += 1;
156        }
157    }
158}