@@ -137,58 +137,61 @@ impl Range {
137137 }
138138 }
139139
140− /// Compute the ends of the range, shifted (if needed) to align with
141− /// grapheme boundaries.
140+ /// Compute a possibly new range from this range, attempting to ensure
141+ /// a minimum range width of 1 char by shifting the head in the forward
142+ /// direction as needed.
142143 ///
143− /// This should generally be used for cursor validation.
144+ /// This method will never shift the anchor, and will only shift the
145+ /// head in the forward direction. Therefore, this method can fail
146+ /// at ensuring the minimum width if and only if the passed range is
147+ /// both zero-width and at the end of the `RopeSlice`.
144148 ///
145− /// Always succeeds.
149+ /// If the input range is grapheme-boundary aligned, the returned range
150+ /// will also be. Specifically, if the head needs to shift to achieve
151+ /// the minimum width, it will shift to the next grapheme boundary.
146152 #[must_use]
147− pub fn aligned_range(&self, slice: RopeSlice) -> (usize, usize) {
153+ #[inline]
154+ pub fn min_width_1(&self, slice: RopeSlice) -> Self {
148155 if self.anchor == self.head {
149− let pos = ensure_grapheme_boundary_prev(slice, self.anchor);
150− (pos, pos)
156+ Range {
157+ anchor: self.anchor,
158+ head: next_grapheme_boundary(slice, self.head),
159+ horiz: self.horiz,
160+ }
151161 } else {
152− (
153− ensure_grapheme_boundary_prev(slice, self.from()),
154− ensure_grapheme_boundary_next(slice, self.to()),
155− )
162+ *self
156163 }
157164 }
158165
159− /// Same as `ensure_grapheme_validity()` + attempts to ensure a minimum
160− /// char width in the direction of the head.
161− ///
162− /// This should generally be used as a pre-pass for operations that
163− /// require a minimum selection width to achieve their intended behavior.
164− ///
165− /// This will fail at ensuring the minimum width only if the passed
166− /// `RopeSlice` is too short in the direction of the head, in which
167− /// case the range will fill the available length in that direction.
166+ /// Compute a possibly new range from this range, with its ends
167+ /// shifted as needed to align with grapheme boundaries.
168168 ///
169− /// Ensuring grapheme-boundary alignment always succeeds.
169+ /// Zero-width ranges will always stay zero-width, and non-zero-width
170+ /// ranges will never collapse to zero-width.
170171 #[must_use]
171− pub fn min_width_range(&self, slice: RopeSlice, min_char_width: usize) -> (usize, usize) {
172− if min_char_width == 0 {
173− return self.aligned_range(slice);
174− }
175−
176− if self.anchor <= self.head {
177− let anchor = ensure_grapheme_boundary_prev(slice, self.anchor);
178− let head = ensure_grapheme_boundary_next(
179− slice,
180− self.head
181− .max(anchor + min_char_width)
182− .min(slice.len_chars()),
183− );
184− (anchor, head)
172+ pub fn grapheme_aligned(&self, slice: RopeSlice) -> Self {
173+ let (new_anchor, new_head) = if self.anchor == self.head {
174+ let pos = ensure_grapheme_boundary_prev(slice, self.anchor);
175+ (pos, pos)
176+ } else if self.anchor < self.head {
177+ (
178+ ensure_grapheme_boundary_prev(slice, self.anchor),
179+ ensure_grapheme_boundary_next(slice, self.head),
180+ )
185181 } else {
186− let anchor = ensure_grapheme_boundary_next(slice, self.anchor);
187− let head = ensure_grapheme_boundary_prev(
188− slice,
189− self.head.min(anchor.saturating_sub(min_char_width)),
190− );
191− (head, anchor)
182+ (
183+ ensure_grapheme_boundary_next(slice, self.anchor),
184+ ensure_grapheme_boundary_prev(slice, self.head),
185+ )
186+ };
187+ Range {
188+ anchor: new_anchor,
189+ head: new_head,
190+ horiz: if new_anchor == self.anchor {
191+ self.horiz
192+ } else {
193+ None
194+ },
192195 }
193196 }
194197
@@ -571,97 +574,127 @@ mod test {
571574
572575 #[test]
573576 fn test_overlaps() {
577+ fn overlaps(a: (usize, usize), b: (usize, usize)) -> bool {
578+ Range::new(a.0, a.1).overlaps(&Range::new(b.0, b.1))
579+ }
580+
574581 // Two non-zero-width ranges, no overlap.
575− assert!(!Range::new(0, 3).overlaps(&Range::new(3, 6)));
576− assert!(!Range::new(0, 3).overlaps(&Range::new(6, 3)));
577− assert!(!Range::new(3, 0).overlaps(&Range::new(3, 6)));
578− assert!(!Range::new(3, 0).overlaps(&Range::new(6, 3)));
579− assert!(!Range::new(3, 6).overlaps(&Range::new(0, 3)));
580− assert!(!Range::new(3, 6).overlaps(&Range::new(3, 0)));
581− assert!(!Range::new(6, 3).overlaps(&Range::new(0, 3)));
582− assert!(!Range::new(6, 3).overlaps(&Range::new(3, 0)));
582+ assert!(!overlaps((0, 3), (3, 6)));
583+ assert!(!overlaps((0, 3), (6, 3)));
584+ assert!(!overlaps((3, 0), (3, 6)));
585+ assert!(!overlaps((3, 0), (6, 3)));
586+ assert!(!overlaps((3, 6), (0, 3)));
587+ assert!(!overlaps((3, 6), (3, 0)));
588+ assert!(!overlaps((6, 3), (0, 3)));
589+ assert!(!overlaps((6, 3), (3, 0)));
583590
584591 // Two non-zero-width ranges, overlap.
585− assert!(Range::new(0, 4).overlaps(&Range::new(3, 6)));
586− assert!(Range::new(0, 4).overlaps(&Range::new(6, 3)));
587− assert!(Range::new(4, 0).overlaps(&Range::new(3, 6)));
588− assert!(Range::new(4, 0).overlaps(&Range::new(6, 3)));
589− assert!(Range::new(3, 6).overlaps(&Range::new(0, 4)));
590− assert!(Range::new(3, 6).overlaps(&Range::new(4, 0)));
591− assert!(Range::new(6, 3).overlaps(&Range::new(0, 4)));
592− assert!(Range::new(6, 3).overlaps(&Range::new(4, 0)));
592+ assert!(overlaps((0, 4), (3, 6)));
593+ assert!(overlaps((0, 4), (6, 3)));
594+ assert!(overlaps((4, 0), (3, 6)));
595+ assert!(overlaps((4, 0), (6, 3)));
596+ assert!(overlaps((3, 6), (0, 4)));
597+ assert!(overlaps((3, 6), (4, 0)));
598+ assert!(overlaps((6, 3), (0, 4)));
599+ assert!(overlaps((6, 3), (4, 0)));
593600
594601 // Zero-width and non-zero-width range, no overlap.
595− assert!(!Range::new(0, 3).overlaps(&Range::new(3, 3)));
596− assert!(!Range::new(3, 0).overlaps(&Range::new(3, 3)));
597− assert!(!Range::new(3, 3).overlaps(&Range::new(0, 3)));
598− assert!(!Range::new(3, 3).overlaps(&Range::new(3, 0)));
602+ assert!(!overlaps((0, 3), (3, 3)));
603+ assert!(!overlaps((3, 0), (3, 3)));
604+ assert!(!overlaps((3, 3), (0, 3)));
605+ assert!(!overlaps((3, 3), (3, 0)));
599606
600607 // Zero-width and non-zero-width range, overlap.
601− assert!(Range::new(1, 4).overlaps(&Range::new(1, 1)));
602− assert!(Range::new(4, 1).overlaps(&Range::new(1, 1)));
603− assert!(Range::new(1, 1).overlaps(&Range::new(1, 4)));
604− assert!(Range::new(1, 1).overlaps(&Range::new(4, 1)));
608+ assert!(overlaps((1, 4), (1, 1)));
609+ assert!(overlaps((4, 1), (1, 1)));
610+ assert!(overlaps((1, 1), (1, 4)));
611+ assert!(overlaps((1, 1), (4, 1)));
605612
606− assert!(Range::new(1, 4).overlaps(&Range::new(3, 3)));
607− assert!(Range::new(4, 1).overlaps(&Range::new(3, 3)));
608− assert!(Range::new(3, 3).overlaps(&Range::new(1, 4)));
609− assert!(Range::new(3, 3).overlaps(&Range::new(4, 1)));
613+ assert!(overlaps((1, 4), (3, 3)));
614+ assert!(overlaps((4, 1), (3, 3)));
615+ assert!(overlaps((3, 3), (1, 4)));
616+ assert!(overlaps((3, 3), (4, 1)));
610617
611618 // Two zero-width ranges, no overlap.
612− assert!(!Range::new(0, 0).overlaps(&Range::new(1, 1)));
613− assert!(!Range::new(1, 1).overlaps(&Range::new(0, 0)));
619+ assert!(!overlaps((0, 0), (1, 1)));
620+ assert!(!overlaps((1, 1), (0, 0)));
614621
615622 // Two zero-width ranges, overlap.
616− assert!(Range::new(1, 1).overlaps(&Range::new(1, 1)));
623+ assert!(overlaps((1, 1), (1, 1)));
617624 }
618625
619626 #[test]
620− fn test_aligned_range() {
627+ fn test_graphem_aligned() {
621628 let r = Rope::from_str("\r\nHi\r\n");
622629 let s = r.slice(..);
623630
624− assert_eq!(Range::new(0, 0).aligned_range(s), (0, 0));
625− assert_eq!(Range::new(0, 1).aligned_range(s), (0, 2));
626− assert_eq!(Range::new(1, 1).aligned_range(s), (0, 0));
627− assert_eq!(Range::new(1, 2).aligned_range(s), (0, 2));
628− assert_eq!(Range::new(2, 2).aligned_range(s), (2, 2));
629− assert_eq!(Range::new(2, 3).aligned_range(s), (2, 3));
630− assert_eq!(Range::new(1, 3).aligned_range(s), (0, 3));
631− assert_eq!(Range::new(3, 5).aligned_range(s), (3, 6));
632− assert_eq!(Range::new(4, 5).aligned_range(s), (4, 6));
633− assert_eq!(Range::new(5, 5).aligned_range(s), (4, 4));
634− assert_eq!(Range::new(6, 6).aligned_range(s), (6, 6));
631+ // Zero-width.
632+ assert_eq!(Range::new(0, 0).grapheme_aligned(s), Range::new(0, 0));
633+ assert_eq!(Range::new(1, 1).grapheme_aligned(s), Range::new(0, 0));
634+ assert_eq!(Range::new(2, 2).grapheme_aligned(s), Range::new(2, 2));
635+ assert_eq!(Range::new(3, 3).grapheme_aligned(s), Range::new(3, 3));
636+ assert_eq!(Range::new(4, 4).grapheme_aligned(s), Range::new(4, 4));
637+ assert_eq!(Range::new(5, 5).grapheme_aligned(s), Range::new(4, 4));
638+ assert_eq!(Range::new(6, 6).grapheme_aligned(s), Range::new(6, 6));
639+
640+ // Forward.
641+ assert_eq!(Range::new(0, 1).grapheme_aligned(s), Range::new(0, 2));
642+ assert_eq!(Range::new(1, 2).grapheme_aligned(s), Range::new(0, 2));
643+ assert_eq!(Range::new(2, 3).grapheme_aligned(s), Range::new(2, 3));
644+ assert_eq!(Range::new(3, 4).grapheme_aligned(s), Range::new(3, 4));
645+ assert_eq!(Range::new(4, 5).grapheme_aligned(s), Range::new(4, 6));
646+ assert_eq!(Range::new(5, 6).grapheme_aligned(s), Range::new(4, 6));
647+
648+ assert_eq!(Range::new(0, 2).grapheme_aligned(s), Range::new(0, 2));
649+ assert_eq!(Range::new(1, 3).grapheme_aligned(s), Range::new(0, 3));
650+ assert_eq!(Range::new(2, 4).grapheme_aligned(s), Range::new(2, 4));
651+ assert_eq!(Range::new(3, 5).grapheme_aligned(s), Range::new(3, 6));
652+ assert_eq!(Range::new(4, 6).grapheme_aligned(s), Range::new(4, 6));
653+
654+ // Reverse.
655+ assert_eq!(Range::new(1, 0).grapheme_aligned(s), Range::new(2, 0));
656+ assert_eq!(Range::new(2, 1).grapheme_aligned(s), Range::new(2, 0));
657+ assert_eq!(Range::new(3, 2).grapheme_aligned(s), Range::new(3, 2));
658+ assert_eq!(Range::new(4, 3).grapheme_aligned(s), Range::new(4, 3));
659+ assert_eq!(Range::new(5, 4).grapheme_aligned(s), Range::new(6, 4));
660+ assert_eq!(Range::new(6, 5).grapheme_aligned(s), Range::new(6, 4));
661+
662+ assert_eq!(Range::new(2, 0).grapheme_aligned(s), Range::new(2, 0));
663+ assert_eq!(Range::new(3, 1).grapheme_aligned(s), Range::new(3, 0));
664+ assert_eq!(Range::new(4, 2).grapheme_aligned(s), Range::new(4, 2));
665+ assert_eq!(Range::new(5, 3).grapheme_aligned(s), Range::new(6, 3));
666+ assert_eq!(Range::new(6, 4).grapheme_aligned(s), Range::new(6, 4));
635667 }
636668
637669 #[test]
638− fn test_min_width_range() {
670+ fn test_min_width_1() {
639671 let r = Rope::from_str("\r\nHi\r\n");
640672 let s = r.slice(..);
641673
642− assert_eq!(Range::new(0, 0).min_width_range(s, 1), (0, 2));
643− assert_eq!(Range::new(0, 1).min_width_range(s, 1), (0, 2));
644− assert_eq!(Range::new(1, 1).min_width_range(s, 1), (0, 2));
645− assert_eq!(Range::new(1, 2).min_width_range(s, 1), (0, 2));
646− assert_eq!(Range::new(2, 2).min_width_range(s, 1), (2, 3));
647− assert_eq!(Range::new(2, 3).min_width_range(s, 1), (2, 3));
648− assert_eq!(Range::new(1, 3).min_width_range(s, 1), (0, 3));
649− assert_eq!(Range::new(3, 5).min_width_range(s, 1), (3, 6));
650− assert_eq!(Range::new(4, 5).min_width_range(s, 1), (4, 6));
651− assert_eq!(Range::new(5, 5).min_width_range(s, 1), (4, 6));
652− assert_eq!(Range::new(6, 6).min_width_range(s, 1), (6, 6));
653−
654− assert_eq!(Range::new(1, 0).min_width_range(s, 1), (0, 2));
655− assert_eq!(Range::new(2, 1).min_width_range(s, 1), (0, 2));
656− assert_eq!(Range::new(3, 2).min_width_range(s, 1), (2, 3));
657− assert_eq!(Range::new(3, 1).min_width_range(s, 1), (0, 3));
658− assert_eq!(Range::new(5, 3).min_width_range(s, 1), (3, 6));
659− assert_eq!(Range::new(5, 4).min_width_range(s, 1), (4, 6));
660−
661− assert_eq!(Range::new(3, 4).min_width_range(s, 3), (3, 6));
662− assert_eq!(Range::new(4, 3).min_width_range(s, 3), (0, 4));
663− assert_eq!(Range::new(3, 4).min_width_range(s, 20), (3, 6));
664− assert_eq!(Range::new(4, 3).min_width_range(s, 20), (0, 4));
674+ // Zero-width.
675+ assert_eq!(Range::new(0, 0).min_width_1(s), Range::new(0, 2));
676+ assert_eq!(Range::new(1, 1).min_width_1(s), Range::new(1, 2));
677+ assert_eq!(Range::new(2, 2).min_width_1(s), Range::new(2, 3));
678+ assert_eq!(Range::new(3, 3).min_width_1(s), Range::new(3, 4));
679+ assert_eq!(Range::new(4, 4).min_width_1(s), Range::new(4, 6));
680+ assert_eq!(Range::new(5, 5).min_width_1(s), Range::new(5, 6));
681+ assert_eq!(Range::new(6, 6).min_width_1(s), Range::new(6, 6));
682+
683+ // Forward.
684+ assert_eq!(Range::new(0, 1).min_width_1(s), Range::new(0, 1));
685+ assert_eq!(Range::new(1, 2).min_width_1(s), Range::new(1, 2));
686+ assert_eq!(Range::new(2, 3).min_width_1(s), Range::new(2, 3));
687+ assert_eq!(Range::new(3, 4).min_width_1(s), Range::new(3, 4));
688+ assert_eq!(Range::new(4, 5).min_width_1(s), Range::new(4, 5));
689+ assert_eq!(Range::new(5, 6).min_width_1(s), Range::new(5, 6));
690+
691+ // Reverse.
692+ assert_eq!(Range::new(1, 0).min_width_1(s), Range::new(1, 0));
693+ assert_eq!(Range::new(2, 1).min_width_1(s), Range::new(2, 1));
694+ assert_eq!(Range::new(3, 2).min_width_1(s), Range::new(3, 2));
695+ assert_eq!(Range::new(4, 3).min_width_1(s), Range::new(4, 3));
696+ assert_eq!(Range::new(5, 4).min_width_1(s), Range::new(5, 4));
697+ assert_eq!(Range::new(6, 5).min_width_1(s), Range::new(6, 5));
665698 }
666699
667700 #[test]