Remove font store

1 files changed, 239 insertions, 0 deletions

diff --git a/src/loading.rs b/src/loading.rs
new file mode 100644
index 00000000..9a32d025
--- /dev/null
+++ b/src/loading.rs
@@ -0,0 +1,239 @@
+//! Resource loading.
+
+use std::fmt::{self, Debug, Formatter};
+use std::io;
+use std::ops::Deref;
+use std::path::Path;
+use std::sync::Arc;
+
+use crate::font::{Font, FontBook};
+use crate::util::Prehashed;
+
+/// A hash that identifies a file.
+///
+/// Such a hash can be [resolved](Loader::resolve) from a path.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct FileHash(pub u64);
+
+/// Loads resources from a local or remote source.
+pub trait Loader {
+    /// Metadata about all known fonts.
+    fn book(&self) -> &FontBook;
+
+    /// Access the font with the given id.
+    fn font(&self, id: usize) -> io::Result<Font>;
+
+    /// Resolve a hash that is the same for this and all other paths pointing to
+    /// the same file.
+    fn resolve(&self, path: &Path) -> io::Result<FileHash>;
+
+    /// Load a file from a path.
+    fn file(&self, path: &Path) -> io::Result<Buffer>;
+}
+
+/// A shared buffer that is cheap to clone.
+#[derive(Clone, Hash, Eq, PartialEq)]
+pub struct Buffer(Prehashed<Arc<Vec<u8>>>);
+
+impl Buffer {
+    /// Return a view into the buffer.
+    pub fn as_slice(&self) -> &[u8] {
+        self
+    }
+
+    /// Return a copy of the buffer as a vector.
+    pub fn to_vec(&self) -> Vec<u8> {
+        self.0.to_vec()
+    }
+}
+
+impl From<&[u8]> for Buffer {
+    fn from(slice: &[u8]) -> Self {
+        Self(Prehashed::new(Arc::new(slice.to_vec())))
+    }
+}
+
+impl From<Vec<u8>> for Buffer {
+    fn from(vec: Vec<u8>) -> Self {
+        Self(Prehashed::new(Arc::new(vec)))
+    }
+}
+
+impl From<Arc<Vec<u8>>> for Buffer {
+    fn from(arc: Arc<Vec<u8>>) -> Self {
+        Self(Prehashed::new(arc))
+    }
+}
+
+impl Deref for Buffer {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<[u8]> for Buffer {
+    fn as_ref(&self) -> &[u8] {
+        self
+    }
+}
+
+impl Debug for Buffer {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.pad("Buffer(..)")
+    }
+}
+
+#[cfg(feature = "fs")]
+pub use fs::*;
+
+#[cfg(feature = "fs")]
+mod fs {
+    use std::fs::{self, File};
+    use std::io;
+    use std::path::{Path, PathBuf};
+
+    use memmap2::Mmap;
+    use same_file::Handle;
+    use walkdir::WalkDir;
+
+    use super::{Buffer, FileHash, Loader};
+    use crate::font::{Font, FontBook, FontInfo};
+
+    /// Loads fonts and files from the local file system.
+    ///
+    /// _This is only available when the `system` feature is enabled._
+    pub struct FsLoader {
+        book: FontBook,
+        paths: Vec<(PathBuf, u32)>,
+    }
+
+    impl FsLoader {
+        /// Create a new system loader.
+        pub fn new() -> Self {
+            Self { book: FontBook::new(), paths: vec![] }
+        }
+
+        /// Builder-style variant of [`search_path`](Self::search_path).
+        pub fn with_path(mut self, dir: impl AsRef<Path>) -> Self {
+            self.search_path(dir);
+            self
+        }
+
+        /// Search for all fonts at a path.
+        ///
+        /// If the path is a directory, all contained fonts will be searched for
+        /// recursively.
+        pub fn search_path(&mut self, path: impl AsRef<Path>) {
+            let walk = WalkDir::new(path)
+                .follow_links(true)
+                .sort_by(|a, b| a.file_name().cmp(b.file_name()))
+                .into_iter()
+                .filter_map(|e| e.ok());
+
+            for entry in walk {
+                let path = entry.path();
+                if let Some(ext) = path.extension().and_then(|s| s.to_str()) {
+                    if matches!(
+                        ext,
+                        "ttf" | "otf" | "TTF" | "OTF" | "ttc" | "otc" | "TTC" | "OTC",
+                    ) {
+                        self.search_file(path);
+                    }
+                }
+            }
+        }
+
+        /// Index the fonts in the file at the given path.
+        ///
+        /// The file may form a font collection and contain multiple fonts,
+        /// which will then all be indexed.
+        fn search_file(&mut self, path: impl AsRef<Path>) {
+            let path = path.as_ref();
+            let path = path.strip_prefix(".").unwrap_or(path);
+            if let Ok(file) = File::open(path) {
+                if let Ok(mmap) = unsafe { Mmap::map(&file) } {
+                    for (i, info) in FontInfo::from_data(&mmap).enumerate() {
+                        self.book.push(info);
+                        self.paths.push((path.into(), i as u32));
+                    }
+                }
+            }
+        }
+
+        /// Builder-style variant of [`search_system`](Self::search_system).
+        pub fn with_system(mut self) -> Self {
+            self.search_system();
+            self
+        }
+
+        /// Search for fonts in the operating system's font directories.
+        pub fn search_system(&mut self) {
+            self.search_system_impl();
+        }
+
+        #[cfg(all(unix, not(target_os = "macos")))]
+        fn search_system_impl(&mut self) {
+            self.search_path("/usr/share/fonts");
+            self.search_path("/usr/local/share/fonts");
+
+            if let Some(dir) = dirs::font_dir() {
+                self.search_path(dir);
+            }
+        }
+
+        #[cfg(target_os = "macos")]
+        fn search_system_impl(&mut self) {
+            self.search_path("/Library/Fonts");
+            self.search_path("/Network/Library/Fonts");
+            self.search_path("/System/Library/Fonts");
+
+            if let Some(dir) = dirs::font_dir() {
+                self.search_path(dir);
+            }
+        }
+
+        #[cfg(windows)]
+        fn search_system_impl(&mut self) {
+            let windir =
+                std::env::var("WINDIR").unwrap_or_else(|_| "C:\\Windows".to_string());
+
+            self.search_path(Path::new(&windir).join("Fonts"));
+
+            if let Some(roaming) = dirs::config_dir() {
+                self.search_path(roaming.join("Microsoft\\Windows\\Fonts"));
+            }
+
+            if let Some(local) = dirs::cache_dir() {
+                self.search_path(local.join("Microsoft\\Windows\\Fonts"));
+            }
+        }
+    }
+
+    impl Loader for FsLoader {
+        fn book(&self) -> &FontBook {
+            &self.book
+        }
+
+        fn font(&self, id: usize) -> io::Result<Font> {
+            let (path, index) = &self.paths[id];
+            let data = self.file(path)?;
+            Font::new(data, *index).ok_or_else(|| io::ErrorKind::InvalidData.into())
+        }
+
+        fn resolve(&self, path: &Path) -> io::Result<FileHash> {
+            let meta = fs::metadata(path)?;
+            if meta.is_file() {
+                let handle = Handle::from_path(path)?;
+                Ok(FileHash(fxhash::hash64(&handle)))
+            } else {
+                Err(io::ErrorKind::NotFound.into())
+            }
+        }
+
+        fn file(&self, path: &Path) -> io::Result<Buffer> {
+            Ok(fs::read(path)?.into())
+        }
+    }
+}