Fontique: add load_system_fonts and load_fonts_from_paths methods (#540)

Adds additional methods with the aim of making `fontique` a suitable
replacement for `fontdb` in resvg:

- `load_system_fonts` loads system fonts into a `Collection` that did
not specify loading them at creation time
- `load_fonts_from_paths` loads all fonts from the specified
directory(s)

---------

Signed-off-by: Nico Burns <nico@nicoburns.com>

Author: nicoburns

fontique/src/collection/mod.rs

@@ -26,6 +26,8 @@ use alloc::{string::String, sync::Arc, vec::Vec};
 use hashbrown::HashMap;
 use read_fonts::types::NameId;
 #[cfg(feature = "std")]
+use std::path::Path;
+#[cfg(feature = "std")]
 use std::sync::{Mutex, atomic::Ordering};
 
 type FamilyMap = HashMap<FamilyId, Option<FamilyInfo>>;
@@ -83,6 +85,19 @@ impl Collection {
         }
     }
 
+    /// Load system fonts. If system fonts are already loaded then this does nothing.
+    pub fn load_system_fonts(&mut self) {
+        if self.inner.system.is_none() {
+            self.inner.load_system_fonts();
+        }
+    }
+
+    /// Loads all fonts contained within the specified directory(s)
+    #[cfg(feature = "std")]
+    pub fn load_fonts_from_paths(&mut self, paths: impl IntoIterator<Item = impl AsRef<Path>>) {
+        self.inner.load_fonts_from_paths(paths);
+    }
+
     /// Returns an iterator over all available family names in the collection.
     ///
     /// If `fontique` was compiled with the `"system"` feature, then it will
@@ -239,6 +254,11 @@ impl Inner {
         }
     }
 
+    /// Load system fonts. If system fonts are already loaded then they will be reloaded.
+    pub fn load_system_fonts(&mut self) {
+        self.system = Some(System::new());
+    }
+
     /// Returns an iterator over all available family names in the collection.
     ///
     /// This includes both system and registered fonts.
@@ -443,6 +463,20 @@ impl Inner {
         self.data.fallbacks.append(key, families)
     }
 
+    /// Loads all fonts that exist in the specified directory(s)
+    #[cfg(feature = "std")]
+    pub fn load_fonts_from_paths(&mut self, paths: impl IntoIterator<Item = impl AsRef<Path>>) {
+        #[cfg(feature = "std")]
+        if let Some(shared) = &self.shared {
+            shared.data.lock().unwrap().load_fonts_from_paths(paths);
+            shared.bump_version();
+        } else {
+            self.data.load_fonts_from_paths(paths);
+        }
+        #[cfg(not(feature = "std"))]
+        self.data.register_fonts(paths)
+    }
+
     /// Registers all fonts that exist in the given data.
     ///
     /// Returns a list of pairs each containing the family identifier and fonts
@@ -626,16 +660,64 @@ struct CommonData {
 }
 
 impl CommonData {
+    #[cfg(feature = "std")]
+    fn load_fonts_from_paths(&mut self, paths: impl IntoIterator<Item = impl AsRef<Path>>) {
+        let mut families: HashMap<FamilyId, (FamilyName, Vec<FontInfo>)> = HashMap::default();
+        let mut scratch_family_name = String::default();
+        crate::scan::scan_paths(paths, 16, |scanned_font| {
+            let source = SourceInfo {
+                id: SourceId::new(),
+                kind: SourceKind::Path(Arc::from(scanned_font.path.unwrap())),
+            };
+
+            let font_data = scanned_font.font.data().as_bytes();
+            self.register_font_impl(
+                font_data,
+                source,
+                None,
+                &mut scratch_family_name,
+                &mut families,
+            );
+        });
+    }
+
     fn register_fonts(
         &mut self,
         data: Blob<u8>,
         info_override: Option<FontInfoOverride<'_>>,
     ) -> Vec<(FamilyId, Vec<FontInfo>)> {
         let mut families: HashMap<FamilyId, (FamilyName, Vec<FontInfo>)> = HashMap::default();
-        let mut family_name = String::default();
-        let data_id = SourceId::new();
-        super::scan::scan_memory(data.as_ref(), |scanned_font| {
-            family_name.clear();
+        let mut scratch_family_name = String::default();
+
+        let source = SourceInfo {
+            id: SourceId::new(),
+            kind: SourceKind::Memory(data.clone()),
+        };
+
+        self.register_font_impl(
+            data.as_ref(),
+            source,
+            info_override,
+            &mut scratch_family_name,
+            &mut families,
+        );
+
+        families
+            .into_iter()
+            .map(|(id, (_, fonts))| (id, fonts))
+            .collect()
+    }
+
+    fn register_font_impl(
+        &mut self,
+        font_data: &[u8],
+        source: SourceInfo,
+        info_override: Option<FontInfoOverride<'_>>,
+        scratch_family_name: &mut String,
+        families: &mut HashMap<FamilyId, (FamilyName, Vec<FontInfo>)>,
+    ) {
+        super::scan::scan_memory(font_data, |scanned_font| {
+            scratch_family_name.clear();
 
             let family_name =
                 if let Some(override_family_name) = info_override.and_then(|o| o.family_name) {
@@ -648,19 +730,18 @@ impl CommonData {
                     let Some(family_chars) = family_chars else {
                         return;
                     };
-                    family_name.extend(family_chars);
-                    &family_name
+                    scratch_family_name.extend(family_chars);
+
+                    #[allow(clippy::needless_borrow)] // false positive
+                    &scratch_family_name
                 };
 
             if family_name.is_empty() {
                 return;
             }
-            let data = SourceInfo {
-                id: data_id,
-                kind: SourceKind::Memory(data.clone()),
-            };
+
             let Some(mut font) =
-                FontInfo::from_font_ref(&scanned_font.font, data, scanned_font.index)
+                FontInfo::from_font_ref(&scanned_font.font, source.clone(), scanned_font.index)
             else {
                 return;
             };
@@ -669,14 +750,14 @@ impl CommonData {
                 font.apply_override(info_override);
             }
 
-            let name = self.family_names.get_or_insert(family_name);
+            let name = self.family_names.get_or_insert(scratch_family_name);
             families
                 .entry(name.id())
                 .or_insert_with(|| (name, Vec::default()))
                 .1
                 .push(font);
         });
-        for (id, (name, fonts)) in &families {
+        for (id, (name, fonts)) in families.iter() {
             if let Some(Some(family)) = self.families.get_mut(id) {
                 let new_fonts = family.fonts().iter().chain(fonts).cloned();
                 *family = FamilyInfo::new(name.clone(), new_fonts);
@@ -685,10 +766,6 @@ impl CommonData {
                 self.families.insert(*id, Some(family));
             }
         }
-        families
-            .into_iter()
-            .map(|(id, (_, fonts))| (id, fonts))
-            .collect()
     }
 
     fn unregister_font(