mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 10:17:02 -06:00
168 lines
9.0 KiB
Rust
168 lines
9.0 KiB
Rust
//! Devanagari shaping: conjuncts, reph, pre-base matras and nukta forms, with their source clusters
|
|
//! and caret stops. The expected forms come from Microsoft's OpenType Devanagari shaping specification
|
|
//! (https://learn.microsoft.com/en-us/typography/script-development/devanagari) and the Unicode
|
|
//! Standard's Devanagari section (https://www.unicode.org/versions/latest/core-spec/chapter-12/).
|
|
//! No font is committed: the tests use an installed face and print SKIPPED when none is found.
|
|
use super::*;
|
|
use kurbo::{BezPath, Point};
|
|
use std::sync::Arc;
|
|
use vectorcraft_doc::{CharStyle, TextKind};
|
|
use vectorcraft_geom::PathData;
|
|
|
|
fn devanagari_test_face(test: &str) -> Option<Arc<FontFace>> {
|
|
let db = FontDb::global();
|
|
// The face must have OpenType (GSUB) Devanagari lookups. An AAT face such as macOS's Devanagari MT
|
|
// shapes with `morx`, and हिन्दी comes out as three clusters because the conjunct न्दी is split in two.
|
|
let opentype = |face: &FontFace| {
|
|
use skrifa::raw::TableProvider;
|
|
face.skrifa()
|
|
.and_then(|f| f.gsub().ok())
|
|
.and_then(|gsub| gsub.script_list().ok())
|
|
.is_some_and(|list| list.script_records().iter().any(|r| matches!(&r.script_tag().to_be_bytes(), b"dev2" | b"deva")))
|
|
};
|
|
let face = ["Kohinoor Devanagari", "ITF Devanagari", "Devanagari Sangam MN", "Noto Sans Devanagari", "Nirmala UI", "Mangal"]
|
|
.into_iter()
|
|
.filter_map(|name| db.face(name, "Regular").filter(|face| face.family == name))
|
|
.find(|face| {
|
|
['क', 'ष', 'र', 'ह', 'न', 'द', '\u{094D}', '\u{093F}', '\u{0940}', '\u{093C}'].iter().all(|&c| face.covers(c)) && opentype(face)
|
|
});
|
|
if let Some(face) = &face {
|
|
let path = face.path().map_or_else(|| "bundled font".to_string(), |p| p.display().to_string());
|
|
eprintln!("ASSERTIONS RUN: {test}; Devanagari font {} {} ({path})", face.family, face.style);
|
|
} else {
|
|
eprintln!("SKIPPED: {test}; no installed candidate font shapes Devanagari through GSUB");
|
|
}
|
|
face
|
|
}
|
|
|
|
fn devanagari_layout(face: &FontFace, text: &str) -> TextLayout {
|
|
let st = CharStyle { font_family: face.family.clone(), font_style: face.style.clone(), size: 20.0, ..CharStyle::default() };
|
|
layout(FontDb::global(), &TextObject::point(Point::ZERO, text, st))
|
|
}
|
|
|
|
fn source_clusters(layout: &TextLayout) -> Vec<(usize, usize)> {
|
|
let mut clusters: Vec<_> = layout.glyphs.iter().map(|glyph| (glyph.byte, glyph.len)).collect();
|
|
clusters.dedup();
|
|
clusters
|
|
}
|
|
|
|
/// The left and right edges of the glyphs of the cluster that starts at `byte`.
|
|
fn cluster_extent(layout: &TextLayout, byte: usize) -> (f64, f64) {
|
|
let glyphs = layout.glyphs.iter().filter(|g| g.byte == byte);
|
|
glyphs.fold((f64::INFINITY, f64::NEG_INFINITY), |(left, right), g| (left.min(g.origin.x), right.max(g.origin.x + g.advance)))
|
|
}
|
|
|
|
#[test]
|
|
fn ka_virama_ssa_forms_one_conjunct_glyph() {
|
|
let Some(face) = devanagari_test_face("ka_virama_ssa_forms_one_conjunct_glyph") else { return };
|
|
// `akhn` substitutes Ka + halant + Ssa with the KaSsa ligature.
|
|
let l = devanagari_layout(&face, "क्ष");
|
|
assert_eq!(l.glyphs.len(), 1, "{:?}", l.glyphs);
|
|
let g = &l.glyphs[0];
|
|
assert_eq!((g.byte, g.len), (0, "क्ष".len()));
|
|
assert!(!['क', 'ष', '\u{094D}'].iter().any(|&c| face.glyph_for(c) == g.gid), "conjunct drawn with a nominal glyph: {}", g.gid);
|
|
}
|
|
|
|
#[test]
|
|
fn reph_is_drawn_after_its_base_consonant() {
|
|
let Some(face) = devanagari_test_face("reph_is_drawn_after_its_base_consonant") else { return };
|
|
// Ra + halant before the base consonant becomes the reph (`rphf`), reordered after the base.
|
|
let s = "र्क";
|
|
let l = devanagari_layout(&face, s);
|
|
let gids: Vec<u32> = l.glyphs.iter().map(|g| g.gid).collect();
|
|
assert_eq!(gids.len(), 2, "{:?}", l.glyphs);
|
|
assert_eq!(gids[0], face.glyph_for('क'), "the base consonant comes first: {gids:?}");
|
|
assert!(![face.glyph_for('र'), face.glyph_for('\u{094D}'), face.glyph_for('क')].contains(&gids[1]), "no reph glyph: {gids:?}");
|
|
assert!(l.glyphs[1].origin.x >= l.glyphs[0].origin.x);
|
|
assert_eq!(source_clusters(&l), vec![(0, s.len())]);
|
|
}
|
|
|
|
#[test]
|
|
fn pre_base_matra_is_drawn_before_its_consonant() {
|
|
let Some(face) = devanagari_test_face("pre_base_matra_is_drawn_before_its_consonant") else { return };
|
|
let s = "कि";
|
|
let l = devanagari_layout(&face, s);
|
|
assert_eq!(l.glyphs.len(), 2, "{:?}", l.glyphs);
|
|
let (matra, ka) = (&l.glyphs[0], &l.glyphs[1]);
|
|
assert_eq!(ka.gid, face.glyph_for('क'));
|
|
assert_ne!(matra.gid, ka.gid);
|
|
assert!(matra.origin.x < ka.origin.x, "the i matra is drawn to the left: {:?}", l.glyphs);
|
|
assert_eq!(source_clusters(&l), vec![(0, s.len())]);
|
|
// The caret stops at the syllable's ends: before the matra, and after the consonant.
|
|
let (left, right) = cluster_extent(&l, 0);
|
|
assert!((caret_position(&l, 0).0.x - left).abs() < 1e-9);
|
|
assert!((caret_position(&l, s.len()).0.x - right).abs() < 1e-9);
|
|
}
|
|
|
|
#[test]
|
|
fn syllables_map_to_their_source_bytes_and_caret_stops() {
|
|
let Some(face) = devanagari_test_face("syllables_map_to_their_source_bytes_and_caret_stops") else { return };
|
|
// हि + न्दी: raw font clusters can subdivide a Unicode editing grapheme.
|
|
let s = "हिन्दी";
|
|
let l = devanagari_layout(&face, s);
|
|
let second = "हि".len();
|
|
let clusters = source_clusters(&l);
|
|
assert_eq!(clusters.first(), Some(&(0, second)), "{clusters:?}");
|
|
let mut end = 0;
|
|
for &(byte, len) in &clusters {
|
|
assert_eq!(byte, end, "source clusters must cover input without gaps or overlaps: {clusters:?}");
|
|
assert!(len > 0, "empty source cluster: {clusters:?}");
|
|
end = byte.checked_add(len).expect("source cluster range overflow");
|
|
assert!(s.get(byte..end).is_some(), "source cluster must span valid UTF-8: {clusters:?}");
|
|
}
|
|
assert_eq!(end, s.len(), "source clusters must cover the whole input: {clusters:?}");
|
|
// The first syllable's i matra is drawn before its consonant.
|
|
assert_eq!(l.glyphs[1].gid, face.glyph_for('ह'), "{:?}", l.glyphs);
|
|
assert!(l.glyphs[0].origin.x < l.glyphs[1].origin.x, "{:?}", l.glyphs);
|
|
// Editing arrows follow Unicode graphemes, regardless of raw cluster subdivision.
|
|
assert_eq!(edit::next_cluster(s, 0), second);
|
|
assert_eq!(edit::next_cluster(s, second), s.len());
|
|
assert_eq!(edit::prev_cluster(s, s.len()), second);
|
|
assert_eq!(caret_horizontal_cluster(&l, s, 0, true), second);
|
|
assert_eq!(caret_horizontal_cluster(&l, s, second, true), s.len());
|
|
assert_eq!(caret_horizontal_cluster(&l, s, s.len(), false), second);
|
|
assert!((caret_position(&l, second).0.x - cluster_extent(&l, 0).1).abs() < 1e-9);
|
|
}
|
|
|
|
#[test]
|
|
fn nukta_forms_match_the_precomposed_letters() {
|
|
let Some(face) = devanagari_test_face("nukta_forms_match_the_precomposed_letters") else { return };
|
|
// U+0958 is canonically equivalent to Ka + nukta and is drawn the same way.
|
|
let composed = devanagari_layout(&face, "\u{0958}");
|
|
let decomposed = devanagari_layout(&face, "\u{0915}\u{093C}");
|
|
let shape = |l: &TextLayout| l.glyphs.iter().map(|g| (g.gid, g.advance, g.origin)).collect::<Vec<_>>();
|
|
assert_eq!(shape(&composed), shape(&decomposed));
|
|
assert_eq!(source_clusters(&decomposed), vec![(0, "\u{0915}\u{093C}".len())]);
|
|
// The nukta joins its consonant: one glyph takes up room on the line.
|
|
assert_eq!(decomposed.glyphs.iter().filter(|g| g.advance > 0.0).count(), 1, "{:?}", decomposed.glyphs);
|
|
}
|
|
|
|
#[test]
|
|
fn a_click_in_a_syllable_goes_to_its_nearer_end() {
|
|
let Some(face) = devanagari_test_face("a_click_in_a_syllable_goes_to_its_nearer_end") else { return };
|
|
let s = "कि";
|
|
let l = devanagari_layout(&face, s);
|
|
let (left, right) = cluster_extent(&l, 0);
|
|
// This point lies just past the matra, still in the left half of the syllable.
|
|
let matra_end = l.glyphs[0].origin.x + l.glyphs[0].advance;
|
|
let near_left = matra_end + 0.1;
|
|
assert!(near_left < (left + right) * 0.5, "the matra takes most of the syllable: {:?}", l.glyphs);
|
|
let y = l.lines[0].baseline;
|
|
assert_eq!(hit_byte(&l, Point::new(near_left, y)), 0);
|
|
assert_eq!(hit_byte(&l, Point::new(right - 0.1, y)), s.len());
|
|
|
|
// Clicks at the same places on a path go to the same ends.
|
|
let mut line = BezPath::new();
|
|
line.move_to((0.0, 50.0));
|
|
line.line_to((500.0, 50.0));
|
|
let st = CharStyle { font_family: face.family.clone(), font_style: face.style.clone(), size: 20.0, ..CharStyle::default() };
|
|
let mut t = TextObject::point(Point::ZERO, s, st);
|
|
t.kind = TextKind::OnPath { path: PathData::from_bezpath(&line), start: 0.0, end: None };
|
|
let p = layout(FontDb::global(), &t);
|
|
assert!(p.on_path && p.glyphs.len() == 2, "{:?}", p.glyphs);
|
|
let x0 = p.glyphs[0].origin.x;
|
|
let matra_end = x0 + p.glyphs[0].advance;
|
|
assert_eq!(hit_byte(&p, Point::new(matra_end + 0.1, 50.0)), 0);
|
|
assert_eq!(hit_byte(&p, Point::new(p.glyphs[1].origin.x + p.glyphs[1].advance - 0.1, 50.0)), s.len());
|
|
}
|