Add WASM target

Author: simoncozens

Cargo.toml

@@ -5,8 +5,11 @@ members = [
     "fontspector-cli",
     "fontspector-checkapi",
     "profile-universal", "profile-testplugin", "profile-googlefonts",
+    "fontspector-web",
 ]
 
+default-members = [ "fontspector-cli" ]
+
 [workspace.dependencies]
 pluginator = "1.0.1"
 

fontspector-checkapi/Cargo.toml

@@ -3,6 +3,13 @@ name = "fontspector-checkapi"
 version = "0.1.0"
 edition = "2021"
 
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+# Plugin architecture
+pluginator = {workspace = true}
+
 [dependencies]
 read-fonts = {workspace = true}
 skrifa = {workspace = true}
@@ -14,9 +21,6 @@ glob="0.3.1"
 # Needed so that we can refer to status codes on the command line
 clap = {version = "3.2.5", features = ["derive"]}
 
-# Plugin architecture
-pluginator = {workspace = true}
-
 # Serializing and deserializing profiles
 toml = "0.8.14"
 serde = { workspace = true }

fontspector-checkapi/src/font.rs

@@ -18,17 +18,30 @@ pub struct TestFont {
 pub const TTF: FileType = FileType { pattern: "*.ttf" };
 
 impl<'a> FileTypeConvert<TestFont> for FileType<'a> {
+    #[cfg(not(target_family = "wasm"))]
     fn from_testable(&self, t: &Testable) -> Option<TestFont> {
         self.applies(t)
             .then(|| TestFont::new(&t.filename))
             .transpose()
             .unwrap_or(None)
     }
+
+    #[cfg(target_family = "wasm")]
+    fn from_testable(&self, t: &Testable) -> Option<TestFont> {
+        self.applies(t)
+            .then(|| TestFont::new_from_data(&t.filename, t.contents.clone()))
+            .transpose()
+            .unwrap_or(None)
+    }
 }
 
 impl TestFont {
     pub fn new(filename: &str) -> std::io::Result<TestFont> {
         let font_data = std::fs::read(filename)?;
+        TestFont::new_from_data(filename, font_data)
+    }
+
+    pub fn new_from_data(filename: &str, font_data: Vec<u8>) -> std::io::Result<TestFont> {
         let mut fnt = TestFont {
             filename: filename.to_string(),
             font_data,
@@ -41,9 +54,23 @@ impl TestFont {
             .mappings()
             .map(|(u, _gid)| u)
             .collect();
-        fnt._sibling_filenames = {
+
+        fnt.find_siblings()?;
+
+        if FontRef::new(&fnt.font_data).is_err() {
+            return Err(std::io::Error::new(
+                ErrorKind::InvalidData,
+                "Can't parse font",
+            ));
+        }
+        Ok(fnt)
+    }
+
+    #[cfg(not(target_family = "wasm"))]
+    fn find_siblings(&mut self) -> std::io::Result<()> {
+        self._sibling_filenames = {
             // All other TTF files in same directory
-            let directory = Path::new(&fnt.filename)
+            let directory = Path::new(&self.filename)
                 .parent()
                 .ok_or(std::io::Error::new(
                     ErrorKind::NotFound,
@@ -59,19 +86,19 @@ impl TestFont {
             paths
                 .flatten()
                 .filter(|x| x.path().extension().map_or(false, |ext| ext == "ttf"))
-                .filter(|x| x.path().to_string_lossy() != fnt.filename)
+                .filter(|x| x.path().to_string_lossy() != self.filename)
                 .map(|x| x.path().to_string_lossy().to_string())
                 .collect()
         };
+        Ok(())
+    }
 
-        if FontRef::new(&fnt.font_data).is_err() {
-            return Err(std::io::Error::new(
-                ErrorKind::InvalidData,
-                "Can't parse font",
-            ));
-        }
-        Ok(fnt)
+    #[cfg(target_family = "wasm")]
+    fn find_siblings(&mut self) -> std::io::Result<()> {
+        self._sibling_filenames = vec![];
+        Ok(())
     }
+
     pub fn font(&self) -> FontRef {
         #[allow(clippy::expect_used)] // We just tested for it in the initializer
         FontRef::new(&self.font_data).expect("Can't happen")

fontspector-checkapi/src/lib.rs

@@ -26,8 +26,10 @@ pub mod prelude {
         Status, StatusList, Testable, TTF,
     };
 }
+
 pub trait Plugin {
     fn register(&self, cr: &mut Registry) -> Result<(), String>;
 }
 
+#[cfg(not(target_family = "wasm"))]
 pluginator::plugin_trait!(Plugin);

fontspector-checkapi/src/registry.rs

@@ -20,6 +20,7 @@ impl<'a> Registry<'a> {
         self.checks.values()
     }
 
+    #[cfg(not(target_family = "wasm"))]
     pub fn load_plugin(&mut self, plugin_path: &str) -> Result<(), String> {
         let plugin = unsafe { crate::load_plugin(plugin_path) }.unwrap_or_else(|e| {
             panic!("Could not load plugin {:?}: {:?}", plugin_path, e);

fontspector-checkapi/src/testable.rs

@@ -2,16 +2,20 @@
 pub struct Testable {
     pub filename: String,
     pub source: Option<String>,
+    #[cfg(target_family = "wasm")]
+    pub contents: Vec<u8>,
 }
 
 impl Testable {
+    #[cfg(not(target_family = "wasm"))]
     pub fn new(filename: &str) -> Self {
         Self {
             filename: filename.to_owned(),
             source: None,
         }
     }
 
+    #[cfg(not(target_family = "wasm"))]
     pub fn new_with_source(filename: &str, source: &str) -> Self {
         Self {
             filename: filename.to_owned(),

fontspector-web/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "fontspector-web"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+wasm-bindgen = { version = "0.2.63" }
+console_error_panic_hook = { version = "0.1.6" }
+js-sys = { version = "0.3.68" }
+fontspector-checkapi = { path = "../fontspector-checkapi" }
+profile-universal = { path = "../profile-universal" }
+profile-googlefonts = { path = "../profile-googlefonts" }
+serde_json = { version = "1.0.96", features = ["preserve_order"] }
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+path = "src/lib.rs"

fontspector-web/src/lib.rs

@@ -0,0 +1,65 @@
+use wasm_bindgen::prelude::*;
+extern crate console_error_panic_hook;
+use fontspector_checkapi::{Check, CheckResult, Context, Plugin, Registry, Testable};
+use profile_googlefonts::GoogleFonts;
+use profile_universal::Universal;
+
+#[wasm_bindgen]
+pub fn test(font_a: &[u8]) -> String {
+    let mut registry = Registry::new();
+    Universal
+        .register(&mut registry)
+        .expect("Couldn't register universal profile, fontspector bug");
+    GoogleFonts
+        .register(&mut registry)
+        .expect("Couldn't register googlefonts profile, fontspector bug");
+    let testable: Testable = Testable {
+        filename: "font.ttf".to_string(),
+        source: None,
+        contents: font_a.to_vec(),
+    };
+    let testables = vec![testable];
+    let profile = registry.get_profile("googlefonts").unwrap();
+    let context = Context {
+        skip_network: true,
+        network_timeout: None,
+        configuration: serde_json::Map::new(),
+    };
+
+    let checkorder: Vec<(String, &Testable, &Check, Context)> = profile
+        .sections
+        .iter()
+        .flat_map(|(sectionname, checknames)| {
+            #[allow(clippy::unwrap_used)] // We previously ensured the check exists in the registry
+            checknames
+                .iter()
+                // .filter(|checkname| included_excluded(checkname, &args))
+                .map(|checkname| {
+                    (
+                        sectionname.clone(),
+                        registry.checks.get(checkname).unwrap(),
+                        context.clone(),
+                    )
+                })
+        })
+        .flat_map(|(sectionname, check, context): (String, &Check, Context)| {
+            testables
+                .iter()
+                .filter(|testable| check.applies(testable, &registry))
+                .map(move |testable| (sectionname.clone(), testable, check, context.clone()))
+        })
+        .collect();
+
+    let results: Vec<CheckResult> = checkorder
+        .iter()
+        .map(|(sectionname, testable, check, context)| {
+            (
+                testable,
+                check,
+                check.run_one(testable, context, sectionname),
+            )
+        })
+        .flat_map(|(_, _, result)| result)
+        .collect();
+    serde_json::to_string(&results).unwrap_or("Couldn't do it".to_string())
+}

fontspector-web/test.js

@@ -0,0 +1,4 @@
+const fs = require('fs');
+const fontspector = require('./pkg');
+const data = fs.readFileSync('../Nunito[wght].ttf')
+console.log(fontspector.test(data))

profile-testplugin/Cargo.toml

@@ -4,9 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [lib]
-crate-type=["dylib"]
+crate-type=["cdylib"]
 
 [dependencies]
 fontspector-checkapi = { path = "../fontspector-checkapi" }
-pluginator = "1.0.1"
 toml = "0.8.14"
+
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+# Plugin architecture
+pluginator = {workspace = true}

profile-testplugin/src/lib.rs

@@ -53,4 +53,6 @@ impl fontspector_checkapi::Plugin for Test {
         cr.register_simple_profile("test", vec![VALIDATE_TOML, SAY_HELLO])
     }
 }
+
+#[cfg(not(target_family = "wasm"))]
 pluginator::plugin_implementation!(fontspector_checkapi::Plugin, Test);