WIP

zed/src/editor/buffer/anchor.rs

@@ -0,0 +1,85 @@
+use super::Buffer;
+use crate::time;
+use anyhow::Result;
+use std::cmp::Ordering;
+use std::ops::Range;
+
+#[derive(Clone, Eq, PartialEq, Debug, Hash)]
+pub enum Anchor {
+    Start,
+    End,
+    Middle {
+        insertion_id: time::Local,
+        offset: usize,
+        bias: AnchorBias,
+    },
+}
+
+#[derive(Clone, Eq, PartialEq, Debug, Hash)]
+pub enum AnchorBias {
+    Left,
+    Right,
+}
+
+impl PartialOrd for AnchorBias {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for AnchorBias {
+    fn cmp(&self, other: &Self) -> Ordering {
+        use AnchorBias::*;
+
+        if self == other {
+            return Ordering::Equal;
+        }
+
+        match (self, other) {
+            (Left, _) => Ordering::Less,
+            (Right, _) => Ordering::Greater,
+        }
+    }
+}
+
+impl Anchor {
+    pub fn cmp(&self, other: &Anchor, buffer: &Buffer) -> Result<Ordering> {
+        if self == other {
+            return Ok(Ordering::Equal);
+        }
+
+        Ok(match (self, other) {
+            (Anchor::Start, _) | (_, Anchor::End) => Ordering::Less,
+            (Anchor::End, _) | (_, Anchor::Start) => Ordering::Greater,
+            (
+                Anchor::Middle {
+                    offset: self_offset,
+                    bias: self_bias,
+                    ..
+                },
+                Anchor::Middle {
+                    offset: other_offset,
+                    bias: other_bias,
+                    ..
+                },
+            ) => buffer
+                .fragment_id_for_anchor(self)?
+                .cmp(buffer.fragment_id_for_anchor(other)?)
+                .then_with(|| self_offset.cmp(other_offset))
+                .then_with(|| self_bias.cmp(other_bias)),
+        })
+    }
+}
+
+pub trait AnchorRangeExt {
+    fn cmp(&self, b: &Range<Anchor>, buffer: &Buffer) -> Result<Ordering>;
+}
+
+impl AnchorRangeExt for Range<Anchor> {
+    fn cmp(&self, other: &Range<Anchor>, buffer: &Buffer) -> Result<Ordering> {
+        Ok(match self.start.cmp(&other.start, buffer)? {
+            Ordering::Equal => other.end.cmp(&self.end, buffer)?,
+            ord @ _ => ord,
+        })
+    }
+}

zed/src/editor/buffer/point.rs

@@ -0,0 +1,100 @@
+use std::{
+    cmp::Ordering,
+    ops::{Add, AddAssign, Sub},
+};
+
+#[derive(Clone, Copy, Default, Eq, PartialEq, Debug, Hash)]
+pub struct Point {
+    pub row: u32,
+    pub column: u32,
+}
+
+impl Point {
+    pub fn new(row: u32, column: u32) -> Self {
+        Point { row, column }
+    }
+
+    pub fn zero() -> Self {
+        Point::new(0, 0)
+    }
+
+    pub fn is_zero(&self) -> bool {
+        self.row == 0 && self.column == 0
+    }
+}
+
+impl<'a> Add<&'a Self> for Point {
+    type Output = Point;
+
+    fn add(self, other: &'a Self) -> Self::Output {
+        if other.row == 0 {
+            Point::new(self.row, self.column + other.column)
+        } else {
+            Point::new(self.row + other.row, other.column)
+        }
+    }
+}
+
+impl Add for Point {
+    type Output = Point;
+
+    fn add(self, other: Self) -> Self::Output {
+        self + &other
+    }
+}
+
+impl<'a> Sub<&'a Self> for Point {
+    type Output = Point;
+
+    fn sub(self, other: &'a Self) -> Self::Output {
+        debug_assert!(*other <= self);
+
+        if self.row == other.row {
+            Point::new(0, self.column - other.column)
+        } else {
+            Point::new(self.row - other.row, self.column)
+        }
+    }
+}
+
+impl Sub for Point {
+    type Output = Point;
+
+    fn sub(self, other: Self) -> Self::Output {
+        self - &other
+    }
+}
+
+impl<'a> AddAssign<&'a Self> for Point {
+    fn add_assign(&mut self, other: &'a Self) {
+        if other.row == 0 {
+            self.column += other.column;
+        } else {
+            self.row += other.row;
+            self.column = other.column;
+        }
+    }
+}
+
+impl PartialOrd for Point {
+    fn partial_cmp(&self, other: &Point) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Point {
+    #[cfg(target_pointer_width = "64")]
+    fn cmp(&self, other: &Point) -> Ordering {
+        let a = (self.row as usize) << 32 | self.column as usize;
+        let b = (other.row as usize) << 32 | other.column as usize;
+        a.cmp(&b)
+    }
+
+    #[cfg(target_pointer_width = "32")]
+    fn cmp(&self, other: &Point) -> Ordering {
+        match self.row.cmp(&other.row) {
+            Ordering::Equal => self.column.cmp(&other.column),
+            comparison @ _ => comparison,
+        }
+    }
+}

zed/src/editor/buffer/text.rs

@@ -0,0 +1,445 @@
+use super::Point;
+use crate::sum_tree::{self, SeekBias, SumTree};
+use arrayvec::ArrayVec;
+use std::{
+    cmp,
+    fmt::{self, Debug},
+    ops::{Bound, Index, Range, RangeBounds},
+    sync::Arc,
+};
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+enum Run {
+    Newline,
+    Chars { len: usize, char_size: u8 },
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)]
+struct ByteOffset(usize);
+
+impl sum_tree::Item for Run {
+    type Summary = TextSummary;
+
+    fn summary(&self) -> Self::Summary {
+        match *self {
+            Run::Newline => TextSummary {
+                chars: 1,
+                bytes: 1,
+                lines: Point::new(1, 0),
+                first_line_len: 0,
+                rightmost_point: Point::new(0, 0),
+            },
+            Run::Chars { len, char_size } => TextSummary {
+                chars: len,
+                bytes: len * char_size as usize,
+                lines: Point::new(0, len as u32),
+                first_line_len: len as u32,
+                rightmost_point: Point::new(0, len as u32),
+            },
+        }
+    }
+}
+
+impl Run {
+    fn char_size(&self) -> u8 {
+        match self {
+            Run::Newline => 1,
+            Run::Chars { char_size, .. } => *char_size,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct TextSummary {
+    pub chars: usize,
+    pub bytes: usize,
+    pub lines: Point,
+    pub first_line_len: u32,
+    pub rightmost_point: Point,
+}
+
+impl<'a> std::ops::AddAssign<&'a Self> for TextSummary {
+    fn add_assign(&mut self, other: &'a Self) {
+        let joined_line_len = self.lines.column + other.first_line_len;
+        if joined_line_len > self.rightmost_point.column {
+            self.rightmost_point = Point::new(self.lines.row, joined_line_len);
+        }
+        if other.rightmost_point.column > self.rightmost_point.column {
+            self.rightmost_point = self.lines + &other.rightmost_point;
+        }
+
+        if self.lines.row == 0 {
+            self.first_line_len += other.first_line_len;
+        }
+
+        self.chars += other.chars;
+        self.bytes += other.bytes;
+        self.lines += &other.lines;
+    }
+}
+
+impl std::ops::AddAssign<Self> for TextSummary {
+    fn add_assign(&mut self, other: Self) {
+        *self += &other;
+    }
+}
+
+impl<'a> sum_tree::Dimension<'a, TextSummary> for TextSummary {
+    fn add_summary(&mut self, summary: &TextSummary) {
+        *self += summary;
+    }
+}
+
+impl<'a> sum_tree::Dimension<'a, TextSummary> for Point {
+    fn add_summary(&mut self, summary: &TextSummary) {
+        *self += &summary.lines;
+    }
+}
+
+impl<'a> sum_tree::Dimension<'a, TextSummary> for ByteOffset {
+    fn add_summary(&mut self, summary: &TextSummary) {
+        self.0 += summary.bytes
+    }
+}
+
+impl<'a> sum_tree::Dimension<'a, TextSummary> for usize {
+    fn add_summary(&mut self, summary: &TextSummary) {
+        *self += summary.chars;
+    }
+}
+
+#[derive(Clone)]
+pub struct Text {
+    text: Arc<str>,
+    runs: SumTree<Run>,
+    range: Range<usize>,
+}
+
+impl From<String> for Text {
+    fn from(text: String) -> Self {
+        let mut runs = Vec::new();
+
+        let mut chars_len = 0;
+        let mut run_char_size = 0;
+        let mut run_chars = 0;
+
+        let mut chars = text.chars();
+        loop {
+            let ch = chars.next();
+            let ch_size = ch.map_or(0, |ch| ch.len_utf8());
+            if run_chars != 0 && (ch.is_none() || ch == Some('\n') || run_char_size != ch_size) {
+                runs.push(Run::Chars {
+                    len: run_chars,
+                    char_size: run_char_size as u8,
+                });
+                run_chars = 0;
+            }
+            run_char_size = ch_size;
+
+            match ch {
+                Some('\n') => runs.push(Run::Newline),
+                Some(_) => run_chars += 1,
+                None => break,
+            }
+            chars_len += 1;
+        }
+
+        let mut tree = SumTree::new();
+        tree.extend(runs);
+        Text {
+            text: text.into(),
+            runs: tree,
+            range: 0..chars_len,
+        }
+    }
+}
+
+impl<'a> From<&'a str> for Text {
+    fn from(text: &'a str) -> Self {
+        Self::from(String::from(text))
+    }
+}
+
+impl Debug for Text {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Text").field(&self.text).finish()
+    }
+}
+
+impl PartialEq for Text {
+    fn eq(&self, other: &Self) -> bool {
+        self.text == other.text
+    }
+}
+
+impl Eq for Text {}
+
+impl<T: RangeBounds<usize>> Index<T> for Text {
+    type Output = str;
+
+    fn index(&self, range: T) -> &Self::Output {
+        let start = match range.start_bound() {
+            Bound::Included(start) => cmp::min(self.range.start + start, self.range.end),
+            Bound::Excluded(_) => unimplemented!(),
+            Bound::Unbounded => self.range.start,
+        };
+        let end = match range.end_bound() {
+            Bound::Included(end) => cmp::min(self.range.start + end + 1, self.range.end),
+            Bound::Excluded(end) => cmp::min(self.range.start + end, self.range.end),
+            Bound::Unbounded => self.range.end,
+        };
+
+        let byte_start = self.abs_byte_offset_for_offset(start);
+        let byte_end = self.abs_byte_offset_for_offset(end);
+        &self.text[byte_start..byte_end]
+    }
+}
+
+impl Text {
+    pub fn range(&self) -> Range<usize> {
+        self.range.clone()
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self[..]
+    }
+
+    pub fn slice<T: RangeBounds<usize>>(&self, range: T) -> Text {
+        let start = match range.start_bound() {
+            Bound::Included(start) => cmp::min(self.range.start + start, self.range.end),
+            Bound::Excluded(_) => unimplemented!(),
+            Bound::Unbounded => self.range.start,
+        };
+        let end = match range.end_bound() {
+            Bound::Included(end) => cmp::min(self.range.start + end + 1, self.range.end),
+            Bound::Excluded(end) => cmp::min(self.range.start + end, self.range.end),
+            Bound::Unbounded => self.range.end,
+        };
+
+        Text {
+            text: self.text.clone(),
+            runs: self.runs.clone(),
+            range: start..end,
+        }
+    }
+
+    pub fn line_len(&self, row: u32) -> u32 {
+        let mut cursor = self.runs.cursor::<usize, Point>();
+        cursor.seek(&self.range.start, SeekBias::Right);
+        let absolute_row = cursor.start().row + row;
+
+        let mut cursor = self.runs.cursor::<Point, usize>();
+        cursor.seek(&Point::new(absolute_row, 0), SeekBias::Right);
+        let prefix_len = self.range.start.saturating_sub(*cursor.start());
+        let line_len = cursor.summary::<usize>(&Point::new(absolute_row + 1, 0), SeekBias::Left);
+        let suffix_len = cursor.start().saturating_sub(self.range.end);
+
+        line_len
+            .saturating_sub(prefix_len)
+            .saturating_sub(suffix_len) as u32
+    }
+
+    pub fn len(&self) -> usize {
+        self.range.end - self.range.start
+    }
+
+    pub fn lines(&self) -> Point {
+        self.abs_point_for_offset(self.range.end) - &self.abs_point_for_offset(self.range.start)
+    }
+
+    pub fn rightmost_point(&self) -> Point {
+        let lines = self.lines();
+
+        let mut candidates = ArrayVec::<[Point; 3]>::new();
+        candidates.push(lines);
+        if lines.row > 0 {
+            candidates.push(Point::new(0, self.line_len(0)));
+            if lines.row > 1 {
+                let mut cursor = self.runs.cursor::<usize, Point>();
+                cursor.seek(&self.range.start, SeekBias::Right);
+                let absolute_start_row = cursor.start().row;
+
+                let mut cursor = self.runs.cursor::<Point, usize>();
+                cursor.seek(&Point::new(absolute_start_row + 1, 0), SeekBias::Right);
+                let summary = cursor.summary::<TextSummary>(
+                    &Point::new(absolute_start_row + lines.row, 0),
+                    SeekBias::Left,
+                );
+
+                candidates.push(Point::new(1, 0) + &summary.rightmost_point);
+            }
+        }
+
+        candidates.into_iter().max_by_key(|p| p.column).unwrap()
+    }
+
+    pub fn point_for_offset(&self, offset: usize) -> Point {
+        self.abs_point_for_offset(self.range.start + offset)
+            - &self.abs_point_for_offset(self.range.start)
+    }
+
+    pub fn offset_for_point(&self, point: Point) -> usize {
+        let mut cursor = self.runs.cursor::<Point, TextSummary>();
+        let abs_point = self.abs_point_for_offset(self.range.start) + &point;
+        cursor.seek(&abs_point, SeekBias::Right);
+        let overshoot = abs_point - &cursor.start().lines;
+        let abs_offset = cursor.start().chars + overshoot.column as usize;
+        abs_offset - self.range.start
+    }
+
+    pub fn summary(&self) -> TextSummary {
+        TextSummary {
+            chars: self.range.end - self.range.start,
+            bytes: self.abs_byte_offset_for_offset(self.range.end)
+                - self.abs_byte_offset_for_offset(self.range.start),
+            lines: self.abs_point_for_offset(self.range.end)
+                - &self.abs_point_for_offset(self.range.start),
+            first_line_len: self.line_len(0),
+            rightmost_point: self.rightmost_point(),
+        }
+    }
+
+    fn abs_point_for_offset(&self, offset: usize) -> Point {
+        let mut cursor = self.runs.cursor::<usize, TextSummary>();
+        cursor.seek(&offset, SeekBias::Right);
+        let overshoot = (offset - cursor.start().chars) as u32;
+        cursor.start().lines + &Point::new(0, overshoot)
+    }
+
+    fn abs_byte_offset_for_offset(&self, offset: usize) -> usize {
+        let mut cursor = self.runs.cursor::<usize, TextSummary>();
+        cursor.seek(&offset, SeekBias::Right);
+        let overshoot = offset - cursor.start().chars;
+        cursor.start().bytes + overshoot * cursor.item().map_or(0, |run| run.char_size()) as usize
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashSet;
+    use std::iter::FromIterator;
+
+    #[test]
+    fn test_basic() {
+        let text = Text::from(String::from("ab\ncd€\nfghij\nkl¢m"));
+        assert_eq!(text.len(), 17);
+        assert_eq!(text.as_str(), "ab\ncd€\nfghij\nkl¢m");
+        assert_eq!(text.lines(), Point::new(3, 4));
+        assert_eq!(text.line_len(0), 2);
+        assert_eq!(text.line_len(1), 3);
+        assert_eq!(text.line_len(2), 5);
+        assert_eq!(text.line_len(3), 4);
+        assert_eq!(text.rightmost_point(), Point::new(2, 5));
+
+        let b_to_g = text.slice(1..9);
+        assert_eq!(b_to_g.as_str(), "b\ncd€\nfg");
+        assert_eq!(b_to_g.len(), 8);
+        assert_eq!(b_to_g.lines(), Point::new(2, 2));
+        assert_eq!(b_to_g.line_len(0), 1);
+        assert_eq!(b_to_g.line_len(1), 3);
+        assert_eq!(b_to_g.line_len(2), 2);
+        assert_eq!(b_to_g.line_len(3), 0);
+        assert_eq!(b_to_g.rightmost_point(), Point::new(1, 3));
+
+        let d_to_i = text.slice(4..11);
+        assert_eq!(d_to_i.as_str(), "d€\nfghi");
+        assert_eq!(&d_to_i[1..5], "€\nfg");
+        assert_eq!(d_to_i.len(), 7);
+        assert_eq!(d_to_i.lines(), Point::new(1, 4));
+        assert_eq!(d_to_i.line_len(0), 2);
+        assert_eq!(d_to_i.line_len(1), 4);
+        assert_eq!(d_to_i.line_len(2), 0);
+        assert_eq!(d_to_i.rightmost_point(), Point::new(1, 4));
+
+        let d_to_j = text.slice(4..=11);
+        assert_eq!(d_to_j.as_str(), "d€\nfghij");
+        assert_eq!(&d_to_j[1..], "€\nfghij");
+        assert_eq!(d_to_j.len(), 8);
+    }
+
+    #[test]
+    fn test_random() {
+        use rand::prelude::*;
+
+        for seed in 0..100 {
+            println!("buffer::text seed: {}", seed);
+            let rng = &mut StdRng::seed_from_u64(seed);
+
+            let len = rng.gen_range(0, 50);
+            let mut string = String::new();
+            for _ in 0..len {
+                if rng.gen_ratio(1, 5) {
+                    string.push('\n');
+                } else {
+                    string.push(rng.gen());
+                }
+            }
+            let text = Text::from(string.clone());
+
+            for _ in 0..10 {
+                let start = rng.gen_range(0, text.len() + 1);
+                let end = rng.gen_range(start, text.len() + 2);
+
+                let string_slice = string
+                    .chars()
+                    .skip(start)
+                    .take(end - start)
+                    .collect::<String>();
+                let expected_line_endpoints = string_slice
+                    .split('\n')
+                    .enumerate()
+                    .map(|(row, line)| Point::new(row as u32, line.chars().count() as u32))
+                    .collect::<Vec<_>>();
+                let text_slice = text.slice(start..end);
+
+                assert_eq!(text_slice.lines(), lines(&string_slice));
+
+                let mut rightmost_points: HashSet<Point> = HashSet::new();
+                for endpoint in &expected_line_endpoints {
+                    if let Some(rightmost_point) = rightmost_points.iter().next().cloned() {
+                        if endpoint.column > rightmost_point.column {
+                            rightmost_points.clear();
+                        }
+                        if endpoint.column >= rightmost_point.column {
+                            rightmost_points.insert(*endpoint);
+                        }
+                    } else {
+                        rightmost_points.insert(*endpoint);
+                    }
+
+                    assert_eq!(text_slice.line_len(endpoint.row as u32), endpoint.column);
+                }
+
+                assert!(rightmost_points.contains(&text_slice.rightmost_point()));
+
+                for _ in 0..10 {
+                    let offset = rng.gen_range(0, string_slice.chars().count() + 1);
+                    let point = lines(&string_slice.chars().take(offset).collect::<String>());
+                    assert_eq!(text_slice.point_for_offset(offset), point);
+                    assert_eq!(text_slice.offset_for_point(point), offset);
+                    if offset < string_slice.chars().count() {
+                        assert_eq!(
+                            &text_slice[offset..offset + 1],
+                            String::from_iter(string_slice.chars().nth(offset)).as_str()
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn lines(s: &str) -> Point {
+        let mut row = 0;
+        let mut column = 0;
+        for ch in s.chars() {
+            if ch == '\n' {
+                row += 1;
+                column = 0;
+            } else {
+                column += 1;
+            }
+        }
+        Point::new(row, column)
+    }
+}