shape_languages

Author: simoncozens

fontspector-py/tests/test_checks_googlefonts.py

@@ -3796,16 +3796,10 @@ def test_check_metadata_unreachable_subsetting(check):
     )
 
 
-@pytest.mark.skip("Check not ported yet.")
 @check_id("googlefonts/glyphsets/shape_languages")
 def test_check_shape_languages(check):
     """Shapes languages in all GF glyphsets."""
 
-    #    FIXME: With the latest version of shaperglot (v0.6.3), our reference
-    #    Cabin-Regular.ttf is not fully passing anymore:
-    #    test_font = TTFont(TEST_FILE("cabin/Cabin-Regular.ttf"))
-    #    assert_PASS(check(test_font))
-
     test_font = TTFont(TEST_FILE("BadGrades/BadGrades-VF.ttf"))
     assert_results_contain(check(test_font), FAIL, "no-glyphset-supported")
 

profile-googlefonts/Cargo.toml

@@ -18,6 +18,7 @@ google-fonts-axisregistry = { git = "https://github.com/googlefonts/axisregistry
 google-fonts-languages = "0"
 google-fonts-subsets = "0"
 google-fonts-glyphsets = { git = "https://github.com/googlefonts/glyphsets" }
+shaperglot = "1"
 indexmap = { workspace = true }
 itertools = { workspace = true }
 markdown-table = { workspace = true }

profile-googlefonts/src/checks/googlefonts/glyphsets/mod.rs

@@ -0,0 +1,2 @@
+mod shape_languages;
+pub use shape_languages::shape_languages;

profile-googlefonts/src/checks/googlefonts/glyphsets/shape_languages.rs

@@ -0,0 +1,93 @@
+use fontspector_checkapi::{prelude::*, testfont, FileTypeConvert};
+use google_fonts_glyphsets::{get_glyphset_coverage, languages_per_glyphset};
+use hashbrown::HashMap;
+use markdown_table::MarkdownTable;
+use shaperglot::{Checker, Languages, ResultCode};
+
+fn table_of_results(
+    context: &Context,
+    _title: &str,
+    results: &HashMap<String, Vec<String>>,
+) -> Result<String, CheckError> {
+    let table = MarkdownTable::new(
+        results
+            .iter()
+            .map(|(message, languages)| vec![message.to_string(), bullet_list(context, languages)])
+            .collect(),
+    );
+    table
+        .as_markdown()
+        .map_err(|_| CheckError::Error("Can't happen (table creation failed)".to_string()))
+}
+#[check(
+    id = "googlefonts/glyphsets/shape_languages",
+    rationale = "
+        This check uses a heuristic to determine which GF glyphsets a font supports.
+        Then it checks the font for correct shaping behaviour for all languages in
+        those glyphsets.
+    ",
+    proposal = "https://github.com/googlefonts/fontbakery/issues/4147",
+    title = "Shapes languages in all GF glyphsets."
+)]
+fn shape_languages(t: &Testable, context: &Context) -> CheckFnResult {
+    let f = testfont!(t);
+    let checker = Checker::new(&t.contents).map_err(|e| CheckError::Error(e.to_string()))?;
+    let languages = Languages::new();
+    let codepoints = f.codepoints(Some(context));
+    let mut warns = HashMap::new();
+    let mut fails = HashMap::new();
+    let mut any_glyphset_supported = false;
+    for (glyphset, coverage) in get_glyphset_coverage(&codepoints).iter() {
+        if coverage.fraction > 0.8 {
+            any_glyphset_supported = true;
+            for language_code in languages_per_glyphset(glyphset)?.iter() {
+                if let Some(language) = languages.get_language(language_code) {
+                    let reporter = checker.check(language);
+                    let name = language.name();
+                    let language_string = format!("{} ({})", language_code, name);
+                    for result in reporter.iter() {
+                        let message = result.to_string();
+                        if result.status == ResultCode::Warn {
+                            warns
+                                .entry(message)
+                                .or_insert(vec![])
+                                .push(language_string.clone());
+                        } else if result.status == ResultCode::Fail {
+                            fails
+                                .entry(message)
+                                .or_insert(vec![])
+                                .push(language_string.clone());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let mut problems = vec![];
+    if !fails.is_empty() {
+        problems.push(Status::fail(
+            "failed-language-shaping",
+            &format!(
+                "Failed language shaping:\n{}",
+                table_of_results(context, "FAIL", &fails)?
+            ),
+        ));
+    }
+    if !warns.is_empty() {
+        problems.push(Status::warn(
+            "warning-language-shaping",
+            &format!(
+                "Warning language shaping:\n{}",
+                table_of_results(context, "WARN", &warns)?
+            ),
+        ));
+    }
+    if !any_glyphset_supported {
+        problems.push(Status::fail("no-glyphset-supported",
+            "No GF glyphset was found to be supported >80%, so language shaping support couldn't get checked.",
+        ));
+    }
+
+    return_result(problems)
+}

profile-googlefonts/src/checks/googlefonts/mod.rs

@@ -54,3 +54,4 @@ mod vertical_metrics;
 pub use vertical_metrics::vertical_metrics;
 mod cjk_vertical_metrics;
 pub use cjk_vertical_metrics::cjk_vertical_metrics;
+pub mod glyphsets;

profile-googlefonts/src/lib.rs

@@ -83,7 +83,7 @@ impl fontspector_checkapi::Plugin for GoogleFonts {
             .add_and_register_check(checks::googlefonts::metadata::valid_nameid25)
             //            .add_and_register_check(checks::googlefonts::metadata::weightclass)
             .add_section("Glyphset Checks")
-            //            .add_and_register_check(checks::googlefonts::glyphsets::shape_languages)
+            .add_and_register_check(checks::googlefonts::glyphsets::shape_languages)
             .add_and_register_check(checks::googlefonts::tofu)
             .add_section("Description Checks");