Merge pull request #94 from LaurenzV/3.2.0

RazrFalcon · web-flow · commit 7b5c622fcd33 · 2024-02-09T15:40:10.000+02:00
Port to 3.2.0
diff --git a/examples/shape.rs b/examples/shape.rs
@@ -30,6 +30,7 @@ OPTIONS:
         --no-clusters                   Do not output cluster indices
         --show-extents                  Output glyph extents
         --show-flags                    Output glyph flags
+        --single-par                    Treat the input string as a single paragraph
         --ned                           No Extra Data; Do not output clusters or advances
 
 ARGS:
@@ -59,6 +60,7 @@ struct Args {
     no_clusters: bool,
     show_extents: bool,
     show_flags: bool,
+    single_par: bool,
     ned: bool,
     free: Vec<String>,
 }
@@ -95,6 +97,7 @@ fn parse_args() -> Result<Args, pico_args::Error> {
         no_clusters: args.contains("--no-clusters"),
         show_extents: args.contains("--show-extents"),
         show_flags: args.contains("--show-flags"),
+        single_par: args.contains("--single-par"),
         ned: args.contains("--ned"),
         free: args
             .finish()
@@ -165,53 +168,61 @@ fn main() {
         std::process::exit(1);
     };
 
-    let mut buffer = rustybuzz::UnicodeBuffer::new();
-    buffer.push_str(&text);
+    let lines = if args.single_par {
+        vec![text.as_str()]
+    } else {
+        text.split("\n").filter(|s| !s.is_empty()).collect()
+    };
 
-    if let Some(d) = args.direction {
-        buffer.set_direction(d);
-    }
+    for text in lines {
+        let mut buffer = rustybuzz::UnicodeBuffer::new();
+        buffer.push_str(&text);
 
-    buffer.set_language(args.language);
+        if let Some(d) = args.direction {
+            buffer.set_direction(d);
+        }
 
-    if let Some(script) = args.script {
-        buffer.set_script(script);
-    }
+        buffer.set_language(args.language.clone());
 
-    buffer.set_cluster_level(args.cluster_level);
+        if let Some(script) = args.script {
+            buffer.set_script(script);
+        }
 
-    if !args.utf8_clusters {
-        buffer.reset_clusters();
-    }
+        buffer.set_cluster_level(args.cluster_level);
 
-    let glyph_buffer = rustybuzz::shape(&face, &args.features, buffer);
+        if !args.utf8_clusters {
+            buffer.reset_clusters();
+        }
 
-    let mut format_flags = rustybuzz::SerializeFlags::default();
-    if args.no_glyph_names {
-        format_flags |= rustybuzz::SerializeFlags::NO_GLYPH_NAMES;
-    }
+        let glyph_buffer = rustybuzz::shape(&face, &args.features, buffer);
 
-    if args.no_clusters || args.ned {
-        format_flags |= rustybuzz::SerializeFlags::NO_CLUSTERS;
-    }
+        let mut format_flags = rustybuzz::SerializeFlags::default();
+        if args.no_glyph_names {
+            format_flags |= rustybuzz::SerializeFlags::NO_GLYPH_NAMES;
+        }
 
-    if args.no_positions {
-        format_flags |= rustybuzz::SerializeFlags::NO_POSITIONS;
-    }
+        if args.no_clusters || args.ned {
+            format_flags |= rustybuzz::SerializeFlags::NO_CLUSTERS;
+        }
 
-    if args.no_advances || args.ned {
-        format_flags |= rustybuzz::SerializeFlags::NO_ADVANCES;
-    }
+        if args.no_positions {
+            format_flags |= rustybuzz::SerializeFlags::NO_POSITIONS;
+        }
 
-    if args.show_extents {
-        format_flags |= rustybuzz::SerializeFlags::GLYPH_EXTENTS;
-    }
+        if args.no_advances || args.ned {
+            format_flags |= rustybuzz::SerializeFlags::NO_ADVANCES;
+        }
 
-    if args.show_flags {
-        format_flags |= rustybuzz::SerializeFlags::GLYPH_FLAGS;
-    }
+        if args.show_extents {
+            format_flags |= rustybuzz::SerializeFlags::GLYPH_EXTENTS;
+        }
 
-    println!("{}", glyph_buffer.serialize(&face, format_flags));
+        if args.show_flags {
+            format_flags |= rustybuzz::SerializeFlags::GLYPH_FLAGS;
+        }
+
+        println!("{}", glyph_buffer.serialize(&face, format_flags));
+    }
 }
 
 fn parse_unicodes(s: &str) -> Result<String, String> {
diff --git a/scripts/gen-shaping-tests.py b/scripts/gen-shaping-tests.py
@@ -10,6 +10,9 @@
 # There is no sane way to test them.
 IGNORE_TESTS = [
     'macos.tests',
+    'coretext.tests',
+    'directwrite.tests',
+    'uniscribe.tests',
 ]
 
 IGNORE_TEST_CASES = [
@@ -115,10 +118,11 @@ def convert_test(hb_dir, hb_shape_exe, tests_name, file_name, idx, data, fonts):
     glyphs_expected = subprocess.run(options_list, check=True, stdout=subprocess.PIPE)\
         .stdout.decode()
 
-    glyphs_expected = glyphs_expected[1:-2]  # remove `[..]\n`
+    glyphs_expected = glyphs_expected.strip()[1:-1]  # remove leading and trailing whitespaces and `[..]`
     glyphs_expected = glyphs_expected.replace('|', '|\\\n         ')
 
     options = options.replace('"', '\\"')
+    options = options.replace(' --single-par', '')
 
     fonts.add(os.path.split(fontfile_rs)[1])
 
diff --git a/scripts/gen-tag-table.py b/scripts/gen-tag-table.py
@@ -330,11 +330,15 @@ def __init__(self):
         self.from_bcp_47 = collections.defaultdict(set)
         # Whether the parser is in a <td> element
         self._td = False
+        # Whether the parser is after a <br> element within the current <tr> element
+        self._br = False
         # The text of the <td> elements of the current <tr> element.
         self._current_tr = []
 
     def handle_starttag(self, tag, attrs):
-        if tag == 'meta':
+        if tag == 'br':
+            self._br = True
+        elif tag == 'meta':
             for attr, value in attrs:
                 if attr == 'name' and value == 'updated_at':
                     self.header = self.get_starttag_text()
@@ -343,6 +347,7 @@ def handle_starttag(self, tag, attrs):
             self._td = True
             self._current_tr.append('')
         elif tag == 'tr':
+            self._br = False
             self._current_tr = []
 
     def handle_endtag(self, tag):
@@ -367,7 +372,7 @@ def handle_endtag(self, tag):
             self.ranks[tag] = rank
 
     def handle_data(self, data):
-        if self._td:
+        if self._td and not self._br:
             self._current_tr[-1] += data
 
     def handle_charref(self, name):
@@ -699,6 +704,8 @@ def get_name(self, lt):
 ot.remove_language_ot('MONT')
 ot.add_language('mnw', 'MONT')
 
+ot.add_language ('mnw-TH', 'MONT')
+
 ot.add_language('no', 'NOR')
 
 ot.add_language('oc-provenc', 'PRO')
diff --git a/src/aat/metamorphosis.rs b/src/aat/metamorphosis.rs
@@ -87,13 +87,13 @@ pub fn apply(plan: &ShapePlan, face: &Face, buffer: &mut Buffer) -> Option<()> {
             };
 
             if reverse {
-                buffer.reverse();
+                buffer.reverse_graphemes();
             }
 
             apply_subtable(&subtable.kind, buffer, face);
 
             if reverse {
-                buffer.reverse();
+                buffer.reverse_graphemes();
             }
         }
     }
diff --git a/src/buffer.rs b/src/buffer.rs
@@ -733,6 +733,60 @@ impl Buffer {
         }
     }
 
+    pub fn reverse_groups<F>(&mut self, group: F, merge_clusters: bool)
+    where
+        F: Fn(&GlyphInfo, &GlyphInfo) -> bool,
+    {
+        if self.is_empty() {
+            return;
+        }
+
+        let mut start = 0;
+
+        for i in 1..self.len {
+            if !group(&self.info[i - 1], &self.info[i]) {
+                if merge_clusters {
+                    self.merge_clusters(start, i);
+                }
+
+                self.reverse_range(start, i);
+                start = i;
+            }
+
+            if merge_clusters {
+                self.merge_clusters(start, i);
+            }
+
+            self.reverse_range(start, i);
+
+            self.reverse();
+        }
+    }
+
+    pub fn reverse_graphemes(&mut self) {
+        self.reverse_groups(
+            _grapheme_group_func,
+            self.cluster_level == BufferClusterLevel::MonotoneCharacters,
+        )
+    }
+
+    pub fn group_end<F>(&self, mut start: usize, group: F) -> usize
+    where
+        F: Fn(&GlyphInfo, &GlyphInfo) -> bool,
+    {
+        start += 1;
+
+        while start < self.len && group(&self.info[start - 1], &self.info[start]) {
+            start += 1;
+        }
+
+        start
+    }
+
+    pub fn reverse_clusters(&mut self) {
+        self.reverse_groups(_cluster_group_func, false);
+    }
+
     #[inline]
     fn reset_clusters(&mut self) {
         for (i, info) in self.info.iter_mut().enumerate() {
@@ -1159,7 +1213,7 @@ impl Buffer {
 
     fn unsafe_to_break_impl(&mut self, start: usize, end: usize) {
         let mut cluster = core::u32::MAX;
-        cluster = Self::_unsafe_to_break_find_min_cluster(&self.info, start, end, cluster);
+        cluster = Self::_infos_find_min_cluster(&self.info, start, end, cluster);
         let unsafe_to_break = Self::_unsafe_to_break_set_mask(&mut self.info, start, end, cluster);
         if unsafe_to_break {
             self.scratch_flags |= BufferScratchFlags::HAS_UNSAFE_TO_BREAK;
@@ -1176,9 +1230,8 @@ impl Buffer {
         assert!(self.idx <= end);
 
         let mut cluster = core::u32::MAX;
-        cluster =
-            Self::_unsafe_to_break_find_min_cluster(self.out_info(), start, self.out_len, cluster);
-        cluster = Self::_unsafe_to_break_find_min_cluster(&self.info, self.idx, end, cluster);
+        cluster = Self::_infos_find_min_cluster(self.out_info(), start, self.out_len, cluster);
+        cluster = Self::_infos_find_min_cluster(&self.info, self.idx, end, cluster);
         let idx = self.idx;
         let out_len = self.out_len;
         let unsafe_to_break1 =
@@ -1341,7 +1394,7 @@ impl Buffer {
         info.cluster = cluster;
     }
 
-    fn _unsafe_to_break_find_min_cluster(
+    fn _infos_find_min_cluster(
         info: &[GlyphInfo],
         start: usize,
         end: usize,
@@ -1452,16 +1505,32 @@ impl Buffer {
     }
 }
 
+pub(crate) fn _cluster_group_func(a: &GlyphInfo, b: &GlyphInfo) -> bool {
+    a.cluster == b.cluster
+}
+
+pub(crate) fn _grapheme_group_func(_: &GlyphInfo, b: &GlyphInfo) -> bool {
+    b.is_continuation()
+}
+
 // TODO: to iter if possible
 
 macro_rules! foreach_cluster {
-    ($buffer:expr, $start:ident, $end:ident, $($body:tt)*) => {{
+    ($buffer:expr, $start:ident, $end:ident, $($body:tt)*) => {
+        foreach_group!($buffer, $start, $end, crate::buffer::_cluster_group_func, $($body)*)
+    };
+}
+
+macro_rules! foreach_group {
+    ($buffer:expr, $start:ident, $end:ident, $group_func:expr, $($body:tt)*) => {{
+        let count = $buffer.len;
         let mut $start = 0;
-        let mut $end = $buffer.next_cluster(0);
-        while $start < $buffer.len {
+        let mut $end = if count > 0 { $buffer.group_end(0, $group_func) } else { 0 };
+
+        while $start < count {
             $($body)*;
             $start = $end;
-            $end = $buffer.next_cluster($start);
+            $end = $buffer.group_end($start, $group_func);
         }
     }};
 }
@@ -1479,15 +1548,9 @@ macro_rules! foreach_syllable {
 }
 
 macro_rules! foreach_grapheme {
-    ($buffer:expr, $start:ident, $end:ident, $($body:tt)*) => {{
-        let mut $start = 0;
-        let mut $end = $buffer.next_grapheme(0);
-        while $start < $buffer.len {
-            $($body)*;
-            $start = $end;
-            $end = $buffer.next_grapheme($start);
-        }
-    }};
+    ($buffer:expr, $start:ident, $end:ident, $($body:tt)*) => {
+        foreach_group!($buffer, $start, $end, crate::buffer::_grapheme_group_func, $($body)*)
+    };
 }
 
 bitflags::bitflags! {
diff --git a/src/shape.rs b/src/shape.rs
@@ -480,22 +480,14 @@ fn ensure_native_direction(buffer: &mut Buffer) {
         }
     }
 
+    // TODO vertical:
+    // The only BTT vertical script is Ogham, but it's not clear to me whether OpenType
+    // Ogham fonts are supposed to be implemented BTT or not.  Need to research that
+    // first.
     if (dir.is_horizontal() && dir != hor && hor != Direction::Invalid)
         || (dir.is_vertical() && dir != Direction::TopToBottom)
     {
-        if buffer.cluster_level == BufferClusterLevel::MonotoneCharacters {
-            foreach_grapheme!(buffer, start, end, {
-                buffer.merge_clusters(start, end);
-                buffer.reverse_range(start, end);
-            });
-        } else {
-            foreach_grapheme!(buffer, start, end, {
-                // form_clusters() merged clusters already, we don't merge.
-                buffer.reverse_range(start, end);
-            })
-        }
-
-        buffer.reverse();
+        buffer.reverse_graphemes();
         buffer.direction = buffer.direction.reverse();
     }
 }
diff --git a/src/tag_table.rs b/src/tag_table.rs

Original file line number	Diff line number	Diff line change
`@@ -87,13 +87,13 @@ pub fn apply(plan: &ShapePlan, face: &Face, buffer: &mut Buffer) -> Option<()> {`
`87`	`87`	`};`
`88`	`88`
`89`	`89`	`if reverse {`
`90`		`- buffer.reverse();`
	`90`	`+ buffer.reverse_graphemes();`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`apply_subtable(&subtable.kind, buffer, face);`
`94`	`94`
`95`	`95`	`if reverse {`
`96`		`- buffer.reverse();`
	`96`	`+ buffer.reverse_graphemes();`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -480,22 +480,14 @@ fn ensure_native_direction(buffer: &mut Buffer) {`
`480`	`480`	`}`
`481`	`481`	`}`
`482`	`482`
	`483`	`+ // TODO vertical:`
	`484`	`+ // The only BTT vertical script is Ogham, but it's not clear to me whether OpenType`
	`485`	`+ // Ogham fonts are supposed to be implemented BTT or not. Need to research that`
	`486`	`+ // first.`
`483`	`487`	`if (dir.is_horizontal() && dir != hor && hor != Direction::Invalid)`
`484`	`488`	`\|\| (dir.is_vertical() && dir != Direction::TopToBottom)`
`485`	`489`	`{`
`486`		`- if buffer.cluster_level == BufferClusterLevel::MonotoneCharacters {`
`487`		`- foreach_grapheme!(buffer, start, end, {`
`488`		`- buffer.merge_clusters(start, end);`
`489`		`- buffer.reverse_range(start, end);`
`490`		`- });`
`491`		`- } else {`
`492`		`- foreach_grapheme!(buffer, start, end, {`
`493`		`- // form_clusters() merged clusters already, we don't merge.`
`494`		`- buffer.reverse_range(start, end);`
`495`		`- })`
`496`		`- }`
`497`		`-`
`498`		`- buffer.reverse();`
	`490`	`+ buffer.reverse_graphemes();`
`499`	`491`	`buffer.direction = buffer.direction.reverse();`
`500`	`492`	`}`
`501`	`493`	`}`