Merge pull request #7 from SimplePixelFont/improve/abi

Improve ABI Error Management

Author: The-Nice-One

.vscode/settings.json

@@ -1,19 +1,28 @@
 {
     "cSpell.words": [
         "bezpath",
+        "bspf",
         "cmap",
         "codepoints",
         "colr",
+        "DOGRAY",
         "glyf",
+        "GRIDFIT",
         "gsub",
         "hhea",
         "hmtx",
+        "kurbo",
         "loca",
         "maxp",
+        "nonmarkingreturn",
+        "notdef",
         "panose",
+        "PICO",
         "pixmap",
         "pixmaps",
         "ppem",
-        "spfc"
+        "Renderable",
+        "spfc",
+        "Subtable"
     ]
 }

Cargo.lock

@@ -1,3 +1,4 @@
+use anyhow::{Error, anyhow};
 use spf::core::layout_from_data;
 use spfc_abi::{BackendInfo, CURRENT_ABI_VERSION, CompileOptions, CompileResult, PluginOption};
 
@@ -21,26 +22,33 @@ fn get_plugin_options() -> Vec<PluginOption> {
 }
 
 #[spfc_abi::export]
-fn compile(options: CompileOptions) -> CompileResult {
-    let data = std::fs::read(&options.input).unwrap();
-    let layout = layout_from_data(&data).unwrap();
-    let font_table = layout.font_tables.first().unwrap();
-    let font = font_table.fonts.first().unwrap();
+fn compile(options: CompileOptions) -> Result<CompileResult, Error> {
+    let data = std::fs::read(&options.input)?;
+    let layout = layout_from_data(&data)
+        .map_err(|e| anyhow!("Failed to parse input data into layout: {e:?}"))?;
+    let font_table = layout
+        .font_tables
+        .first()
+        .ok_or_else(|| anyhow!("No font tables found"))?;
+    let font = font_table
+        .fonts
+        .first()
+        .ok_or_else(|| anyhow!("No fonts found in font table"))?;
 
     let mut process = Process::default();
     process.family_name = font.name.clone();
     process.family_version = font.version as f64;
     process.manufacturer = font.author.clone();
     process.pixmap_pairs = create_pixmap_pairs(&layout);
 
-    let font_data = create_program_string(&process).unwrap();
-    std::fs::write(&options.output, &font_data).unwrap();
+    let font_data = create_program_string(&process)?;
+    std::fs::write(&options.output, &font_data)?;
 
     println!(
         "Finished writing {} bytes to {}",
         font_data.len(),
         options.output
     );
 
-    CompileResult::Success
+    Ok(CompileResult::Success)
 }

backends/spfc-target-p8/src/lib.rs

@@ -28,7 +28,7 @@ impl TextureBuilder<PixmapGlyph> for PixmapGlyphTextureBuilder {
         let bits_per_pixel = pixmap_table
             .constant_bits_per_pixel
             .or(pixmap.custom_bits_per_pixel)
-            .unwrap();
+            .unwrap_or(1);
 
         let advance_x = character.advance_x.unwrap_or(width);
         if advance_x != width {

backends/spfc-target-p8/src/utilities/pixmap.rs

@@ -1,6 +1,6 @@
 [package]
 name = "spfc-target-ttf"
-version = "0.1.0"
+version = "0.1.1"
 edition.workspace = true
 
 [lib]

backends/spfc-target-ttf/Cargo.toml

@@ -1,7 +1,7 @@
 use crate::utilities::PixelGrid;
 
 use super::Process;
-use anyhow::Result;
+use anyhow::{Error, Result};
 use kurbo::BezPath;
 use write_fonts::tables::glyf::{GlyfLocaBuilder, SimpleGlyph};
 
@@ -21,14 +21,20 @@ pub fn push_glyf_loca_tables(process: &mut Process) -> Result<()> {
         process.max_pixel_height as usize - process.descender_pixels as usize - 1,
     );
     let notdef =
-        SimpleGlyph::from_bezpath(&notdef.to_bezpath(process.descender_pixels as usize)).unwrap();
+        SimpleGlyph::from_bezpath(&notdef.to_bezpath(process.descender_pixels as usize)?).map_err(
+            |x| Error::msg(format!("{x:?}"))
+        )?;
     glyf_builder.add_glyph(&notdef)?;
 
-    let null_glyph = SimpleGlyph::from_bezpath(&BezPath::new()).unwrap();
+    let null_glyph = SimpleGlyph::from_bezpath(&BezPath::new()).map_err(
+            |x| Error::msg(format!("{x:?}"))
+        )?;
     glyf_builder.add_glyph(&null_glyph)?;
 
     // Glyph 2: nonmarkingreturn (empty glyph for tab/return)
-    let nonmarkingreturn = SimpleGlyph::from_bezpath(&BezPath::new()).unwrap();
+    let nonmarkingreturn = SimpleGlyph::from_bezpath(&BezPath::new()).map_err(
+            |x| Error::msg(format!("{x:?}"))
+        )?;
     glyf_builder.add_glyph(&nonmarkingreturn)?;
 
     for (_, pixmap) in &process.pixmap_pairs {
@@ -37,15 +43,15 @@ pub fn push_glyf_loca_tables(process: &mut Process) -> Result<()> {
         let glyph = pixmap.clone().into_simple_glyph(
             process.target_pixel_size as u16,
             process.descender_pixels as usize,
-        );
+        )?;
         glyf_builder.add_glyph(&glyph)?;
     }
 
     for pixmap in &process.color_layer_glyphs {
         let glyph = pixmap.clone().into_simple_glyph(
             process.target_pixel_size as u16,
             process.descender_pixels as usize,
-        );
+        )?;
         glyf_builder.add_glyph(&glyph)?;
     }
 

backends/spfc-target-ttf/src/builders/glyf_loca.rs

@@ -13,8 +13,7 @@ fn unix_to_mac_epoch(unix_time: u64) -> i64 {
 
 pub fn push_head_table(process: &mut Process) -> Result<()> {
     let now = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
+        .duration_since(UNIX_EPOCH)?
         .as_secs();
     let mac_timestamp = unix_to_mac_epoch(now);
 

backends/spfc-target-ttf/src/builders/head.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use anyhow::Result;
 use render_spf::PixelRef;
 use spf::core::Layout;
 
@@ -255,7 +256,7 @@ impl Process<'_> {
         let dynamic_glyphs = u16::try_from(dynamic_glyphs).unwrap_or(u16::MAX);
         AUTOINSERTED_CHARS_COUNT.saturating_add(dynamic_glyphs)
     }
-    pub fn update_max_points_and_contours(&mut self) {
+    pub fn update_max_points_and_contours(&mut self) -> Result<()> {
         self.max_points = 0;
         self.max_contours = 0;
 
@@ -267,7 +268,7 @@ impl Process<'_> {
             let glyph = pixmap.clone().into_simple_glyph(
                 self.target_pixel_size as u16,
                 self.descender_pixels as usize,
-            );
+            )?;
 
             let mut points = 0;
             for contour in &glyph.contours {
@@ -277,5 +278,6 @@ impl Process<'_> {
             self.max_points = self.max_points.max(points);
             self.max_contours = self.max_contours.max(contours);
         }
+        Ok(())
     }
 }