Merge pull request #119 from kas-gui/push-upmonwkyrtvx

Replace usage of swash::text with icu4x

Author: dhardy

Cargo.toml

@@ -51,7 +51,9 @@ log = "0.4"
 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"
+fontique = { version = "0.7.0", features = ["icu_properties"] }
+icu_properties = "2.1.1"
+icu_segmenter = "2.1.2"
 
 [dependencies.rustybuzz]
 version = "0.20.1"

src/display/text_runs.rs

@@ -11,9 +11,10 @@ use super::TextDisplay;
 use crate::conv::{to_u32, to_usize};
 use crate::fonts::{self, FontSelector, NoFontMatch};
 use crate::format::FormattableText;
-use crate::{Direction, Range, script_to_fontique, shaper};
-use swash::text::LineBreak as LB;
-use swash::text::cluster::Boundary;
+use crate::util::ends_with_hard_break;
+use crate::{Direction, Range, shaper};
+use icu_properties::{CodePointMapData, props::Script};
+use icu_segmenter::LineSegmenter;
 use unicode_bidi::{BidiInfo, LTR_LEVEL, RTL_LEVEL};
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -195,14 +196,17 @@ impl TextDisplay {
             text,
             dpem,
             level: levels.first().cloned().unwrap_or(LTR_LEVEL),
-            script: UNKNOWN_SCRIPT,
+            script: Script::Unknown.into(),
         };
 
         let mut start = 0;
         let mut breaks = Default::default();
 
-        let mut analyzer = swash::text::analyze(text.chars());
-        let mut last_props = None;
+        // 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 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 script = CodePointMapData::<Script>::new().get(c);
 
-            // 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;
@@ -238,14 +244,12 @@ impl TextDisplay {
             }
 
             let mut new_script = None;
-            if props.script().is_real() {
+            if !matches!(script, Script::Common | Script::Unknown | Script::Inherited) {
                 if first_real.is_none() && !c.is_control() {
                     first_real = Some(c);
                 }
-                let script = script_to_fontique(props.script());
-                if input.script == UNKNOWN_SCRIPT {
-                    input.script = script;
-                } else if script != UNKNOWN_SCRIPT && script != input.script {
+                let script = script.into();
+                if script != input.script {
                     new_script = Some(script);
                 }
             }
@@ -265,7 +269,7 @@ impl TextDisplay {
                 start = index;
                 non_control_end = index;
                 input.level = levels[index];
-                input.script = UNKNOWN_SCRIPT;
+                input.script = Script::Unknown.into();
                 breaks = Default::default();
             } else if is_break && !is_control {
                 // We do break runs when hitting control chars, but only when
@@ -281,10 +285,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 {
@@ -340,16 +342,3 @@ impl TextDisplay {
         Ok(())
     }
 }
-
-trait ScriptExt {
-    #[allow(clippy::wrong_self_convention)]
-    fn is_real(self) -> bool;
-}
-impl ScriptExt for swash::text::Script {
-    fn is_real(self) -> bool {
-        use swash::text::Script::*;
-        !matches!(self, Common | Unknown | Inherited)
-    }
-}
-
-pub(crate) const UNKNOWN_SCRIPT: fontique::Script = fontique::Script(*b"Zzzz");

src/lib.rs

@@ -29,9 +29,6 @@ pub use display::*;
 pub mod fonts;
 pub mod format;
 
-mod swash_convert;
-pub(crate) use swash_convert::script_to_fontique;
-
 mod text;
 pub use text::*;
 

src/swash_convert.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
     }
 }