Replace swash with icu_segmenter for line-break analysis

Author: dhardy

Cargo.toml

@@ -52,6 +52,8 @@ serde = { version = "1.0.123", features = ["derive"], optional = true }
 ab_glyph = { version = "0.2.10", optional = true }
 swash = "0.2.4"
 fontique = "0.7.0"
+icu_properties = "2.1.1"
+icu_segmenter = "2.1.2"
 
 [dependencies.rustybuzz]
 version = "0.20.1"

src/display/text_runs.rs

@@ -11,9 +11,9 @@ use super::TextDisplay;
 use crate::conv::{to_u32, to_usize};
 use crate::fonts::{self, FontSelector, NoFontMatch};
 use crate::format::FormattableText;
+use crate::util::ends_with_hard_break;
 use crate::{Direction, Range, script_to_fontique, shaper};
-use swash::text::LineBreak as LB;
-use swash::text::cluster::Boundary;
+use icu_segmenter::LineSegmenter;
 use unicode_bidi::{BidiInfo, LTR_LEVEL, RTL_LEVEL};
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -201,8 +201,12 @@ impl TextDisplay {
         let mut start = 0;
         let mut breaks = Default::default();
 
+        // TODO: allow segmenter configuration
+        let segmenter = LineSegmenter::new_auto(Default::default());
+        let mut break_iter = segmenter.segment_str(text);
+        let mut next_break = break_iter.next();
+
         let mut analyzer = swash::text::analyze(text.chars());
-        let mut last_props = None;
         let mut first_real = None;
 
         let mut last_is_control = false;
@@ -218,13 +222,15 @@ impl TextDisplay {
             let is_htab = c == '\t';
             let control_break = is_htab || (last_is_control && !is_control);
 
-            let (props, boundary) = analyzer.next().unwrap();
-            last_props = Some(props);
+            let (props, _) = analyzer.next().unwrap();
 
-            // Forcibly end the line?
-            let hard_break = boundary == Boundary::Mandatory;
             // Is wrapping allowed at this position?
-            let is_break = hard_break || boundary == Boundary::Line;
+            let is_break = next_break == Some(index);
+            // Forcibly end the line?
+            let hard_break = is_break && ends_with_hard_break(&text[..index]);
+            if is_break {
+                next_break = break_iter.next();
+            }
 
             // Force end of current run?
             let bidi_break = levels[index] != input.level;
@@ -282,9 +288,8 @@ impl TextDisplay {
         }
 
         debug_assert!(analyzer.next().is_none());
-        let hard_break = last_props
-            .map(|props| matches!(props.line_break(), LB::BK | LB::CR | LB::LF | LB::NL))
-            .unwrap_or(false);
+        let is_break = next_break == Some(text.len());
+        let hard_break = is_break && ends_with_hard_break(&text);
 
         // Conclude: add last run. This may be empty, but we want it anyway.
         if !last_is_control {

src/util.rs

@@ -5,9 +5,9 @@
 
 //! Utility types and traits
 
+use icu_properties::{CodePointMapData, props::LineBreak};
+use icu_segmenter::{LineSegmenter, iterators::LineBreakIterator, scaffold::Utf8};
 use std::ops::Range;
-use std::str::{CharIndices, Chars};
-use swash::text::cluster::Boundary;
 
 /// Describes the state-of-preparation of a [`TextDisplay`][crate::TextDisplay]
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Ord, PartialOrd, Hash)]
@@ -68,27 +68,44 @@ impl<T: Clone> Iterator for OwningVecIter<T> {
 impl<T: Clone> ExactSizeIterator for OwningVecIter<T> {}
 impl<T: Clone> std::iter::FusedIterator for OwningVecIter<T> {}
 
+/// Returns `true` when `text` ends with a hard break, assuming that it ends
+/// with a valid line break.
+///
+/// This filter is copied from icu_segmenter docs.
+pub(crate) fn ends_with_hard_break(text: &str) -> bool {
+    text.chars().next_back().is_some_and(|c| {
+        matches!(
+            CodePointMapData::<LineBreak>::new().get(c),
+            LineBreak::MandatoryBreak
+                | LineBreak::CarriageReturn
+                | LineBreak::LineFeed
+                | LineBreak::NextLine
+        )
+    })
+}
+
 /// Iterator over lines / paragraphs within the text
 ///
 /// This iterator splits the input text into a sequence of "lines" at mandatory
 /// breaks (see [TR14#BK](https://www.unicode.org/reports/tr14/#BK)).
 /// The resulting slices cover the whole input text in order without overlap.
 pub struct LineIterator<'a> {
-    analyzer: swash::text::Analyze<Chars<'a>>,
-    char_indices: CharIndices<'a>,
+    break_iter: LineBreakIterator<'static, 'a, Utf8>,
+    text: &'a str,
     start: usize,
-    len: usize,
 }
 
 impl<'a> LineIterator<'a> {
     /// Construct
     #[inline]
     pub fn new(text: &'a str) -> Self {
+        let segmenter = LineSegmenter::new_auto(Default::default());
+        let mut break_iter = segmenter.segment_str(text);
+        assert_eq!(break_iter.next(), Some(0)); // the iterator always reports a break at 0
         LineIterator {
-            analyzer: swash::text::analyze(text.chars()),
-            char_indices: text.char_indices(),
+            break_iter,
+            text,
             start: 0,
-            len: text.len(),
         }
     }
 }
@@ -97,24 +114,13 @@ impl<'a> Iterator for LineIterator<'a> {
     type Item = Range<usize>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.start >= self.len {
-            return None;
-        }
-
-        for (index, _) in self.char_indices.by_ref() {
-            let (_, boundary) = self.analyzer.next().unwrap();
-
-            if index > 0 && boundary == Boundary::Mandatory {
+        while let Some(index) = self.break_iter.next() {
+            if ends_with_hard_break(&self.text[..index]) || index == self.text.len() {
                 let range = self.start..index;
                 self.start = index;
                 return Some(range);
             }
         }
-
-        debug_assert!(self.analyzer.next().is_none());
-
-        let range = self.start..self.len;
-        self.start = self.len;
-        Some(range)
+        None
     }
 }