Port font handling to fontdock and ttf-parser 🛳

- Use fontdock for indexing fonts and querying
- Typst binary now automatically indexes and uses system fonts in addition to a fixed font folder!
- Removes subsetting support for now (was half-finished anyways, plan is to use harfbuzz for subsetting in the future)
- Adds font width configuration support

2 files changed, 41 insertions, 27 deletions

diff --git a/tests/src/render.py b/tests/src/render.py
index 30289c3b..0ef8ae2b 100644
--- a/tests/src/render.py
+++ b/tests/src/render.py
@@ -29,10 +29,10 @@ class MultiboxRenderer:
     def __init__(self, data):
         self.combined = None
 
-        self.fonts = {}
-        for entry in data["fonts"]:
-            index = int(entry[0]["id"]), int(entry[0]["variant"])
-            self.fonts[index] = os.path.join(BASE, '../../../fonts', entry[1])
+        self.faces = {}
+        for entry in data["faces"]:
+            face_id = int(entry[0]["index"]), int(entry[0]["variant"])
+            self.faces[face_id] = os.path.join(BASE, '../../../fonts', entry[1])
 
         self.layouts = data["layouts"]
 
@@ -45,7 +45,7 @@ class MultiboxRenderer:
         for layout in self.layouts:
             size = layout["dimensions"]
 
-            renderer = BoxRenderer(self.fonts, size["x"], size["y"])
+            renderer = BoxRenderer(self.faces, size["x"], size["y"])
             for action in layout["actions"]:
                 renderer.execute(action)
 
@@ -87,8 +87,8 @@ class MultiboxRenderer:
 
 
 class BoxRenderer:
-    def __init__(self, fonts, width, height, grid=False):
-        self.fonts = fonts
+    def __init__(self, faces, width, height, grid=False):
+        self.faces = faces
         self.size = (pix(width), pix(height))
 
         img = Image.new('RGBA', self.size, (255, 255, 255, 255))
@@ -126,9 +126,9 @@ class BoxRenderer:
             self.cursor = [pix(args[0]["x"]), pix(args[0]["y"])]
 
         elif cmd == 1:
-            index = int(args[0]["id"]), int(args[0]["variant"])
+            face_id = int(args[0]["index"]), int(args[0]["variant"])
             size = pix(args[1])
-            self.font = ImageFont.truetype(self.fonts[index], size)
+            self.font = ImageFont.truetype(self.faces[face_id], size)
 
         elif cmd == 2:
             text = args[0]
diff --git a/tests/src/typeset.rs b/tests/src/typeset.rs
index 2126615e..f6ad0811 100644
--- a/tests/src/typeset.rs
+++ b/tests/src/typeset.rs
@@ -1,3 +1,4 @@
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::error::Error;
 use std::ffi::OsStr;
@@ -5,19 +6,21 @@ use std::fs::{File, create_dir_all, read_dir, read_to_string};
 use std::io::BufWriter;
 use std::panic;
 use std::process::Command;
+use std::rc::Rc;
 use std::time::{Instant, Duration};
 
 use serde::Serialize;
 use futures_executor::block_on;
 
-use typstc::{Typesetter, DebugErrorProvider};
+use typstc::Typesetter;
+use typstc::font::DynProvider;
 use typstc::layout::MultiLayout;
 use typstc::length::{Length, Size, Value4};
 use typstc::style::PageStyle;
 use typstc::paper::PaperClass;
 use typstc::export::pdf;
-use toddle::query::FontIndex;
-use toddle::query::fs::EagerFsProvider;
+use fontdock::{FaceId, FontLoader};
+use fontdock::fs::{FsIndex, FsProvider};
 
 type DynResult<T> = Result<T, Box<dyn Error>>;
 
@@ -47,12 +50,20 @@ fn main() -> DynResult<()> {
     }
 
     let len = filtered.len();
-    println!();
-    println!("Running {} test{}", len, if len > 1 { "s" } else { "" });
+    if len == 0 {
+        return Ok(());
+    } else if len == 1 {
+        println!("Running test ...");
+    } else {
+        println!("Running {} tests", len);
+    }
+
+    let mut index = FsIndex::new();
+    index.search_dir("../fonts");
 
     for (name, src) in filtered {
         panic::catch_unwind(|| {
-            if let Err(e) = test(&name, &src) {
+            if let Err(e) = test(&name, &src, &index) {
                 println!("error: {:?}", e);
             }
         }).ok();
@@ -62,13 +73,15 @@ fn main() -> DynResult<()> {
 }
 
 /// Create a _PDF_ and render with a name from the source code.
-fn test(name: &str, src: &str) -> DynResult<()> {
+fn test(name: &str, src: &str, index: &FsIndex) -> DynResult<()> {
     println!("Testing: {}.", name);
 
-    let (fs, entries) = EagerFsProvider::from_index("../fonts", "index.json")?;
-    let files = fs.files().to_vec();
-    let provider = DebugErrorProvider::new(fs);
-    let mut typesetter = Typesetter::new((Box::new(provider), entries));
+    let (descriptors, files) = index.clone().into_vecs();
+    let provider = FsProvider::new(files.clone());
+    let dynamic = Box::new(provider) as Box<DynProvider>;
+    let loader = FontLoader::new(dynamic, descriptors);
+    let loader = Rc::new(RefCell::new(loader));
+    let mut typesetter = Typesetter::new(loader.clone());
 
     typesetter.set_page_style(PageStyle {
         class: PaperClass::Custom,
@@ -81,24 +94,25 @@ fn test(name: &str, src: &str) -> DynResult<()> {
     // Write the PDF file.
     let path = format!("tests/cache/{}.pdf", name);
     let file = BufWriter::new(File::create(path)?);
-    pdf::export(&layouts, typesetter.loader(), file)?;
+    pdf::export(&layouts, &loader, file)?;
 
     // Compute the font's paths.
-    let mut fonts = HashMap::new();
+    let mut faces = HashMap::new();
     for layout in &layouts {
-        for index in layout.find_used_fonts() {
-            fonts.entry(index)
-                .or_insert_with(|| files[index.id][index.variant].as_str());
+        for id in layout.find_used_fonts() {
+            faces.entry(id).or_insert_with(|| {
+                files[id.index][id.variant].0.to_str().unwrap()
+            });
         }
     }
 
     #[derive(Serialize)]
     struct Document<'a> {
-        fonts: Vec<(FontIndex, &'a str)>,
+        faces: Vec<(FaceId, &'a str)>,
         layouts: MultiLayout,
     }
 
-    let document = Document { fonts: fonts.into_iter().collect(), layouts};
+    let document = Document { faces: faces.into_iter().collect(), layouts };
 
     // Serialize the document into JSON.
     let path = format!("tests/cache/{}.serde.json", name);