Files
vectorcraft/crates/text/src/tests/devanagari.rs
T
dotCooCoo 3bcdbd7e71 Type: letter spacing and Full Justify keep shaped clusters together
Single Word Justification's Full Justify counted and placed a gap after
every drawn glyph, so a combining mark or the vowel sign of a Devanagari
syllable moved away from its letter. Desired Letter Spacing and the
letter spacing range of a justified line did the same between two glyphs
of one cluster.

- The Full Justify gap count and placement share one check that skips
  glyphs with the same cluster byte as the glyph drawn after them.
- Letter spacing goes after the last glyph of a cluster only.
- Letter spacing, Full Justify and CJK inter-character gaps pass over
  every default-ignorable character drawn with no width (soft hyphens,
  bidi marks, embeddings, overrides and isolates, joiners, word joiners,
  variation selectors, tags, the byte order mark) and put the space
  between the visible characters on either side. The Hangul fillers stay
  letters.
- A zero-width space takes no word-space room on a justified line and
  stays a line break opportunity. Letter spacing before it is set after
  it, so a line broken there ends at its last letter.
- A single word that Full Justify spreads and that breaks at a hyphen
  has the same gap before the drawn hyphen as between its letters.
- Kinsoku push-in counts the gaps it can close past format controls, as
  the layout closes them.

Tests cover horizontal, right-to-left and vertical type, Desired and
fitted letter spacing, format controls, zero-width spaces, the drawn
hyphen, push-in, and a Devanagari syllable when a Devanagari face is
installed.
2026-11-12 06:54:44 -08:00

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 crate::*;
use kurbo::{BezPath, Point};
use std::sync::Arc;
use vectorcraft_doc::{CharStyle, TextKind};
use vectorcraft_geom::PathData;
pub(super) 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());
}