feat: generic ruby renderer

.gitignore

···
 /target
+
+*.ttf
+*.ttc
+*.otf
+*.woff2

Cargo.lock

···
 checksum = "e225f595052d9c46045755be4b8d7950b6d9f3c33e0c0b74ba58f11bbfa8c64b"
 
 [[package]]
-name = "pinyinify"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "clap",
- "font-types",
- "fontcull",
- "fontcull-font-types",
- "fontcull-klippa",
- "fontcull-read-fonts",
- "kurbo",
- "pinyin",
- "read-fonts",
- "skrifa",
- "woofwoof",
- "write-fonts",
-]
-
-[[package]]
 name = "proc-macro2"
 version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rubify"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "font-types",
+ "fontcull",
+ "fontcull-font-types",
+ "fontcull-klippa",
+ "fontcull-read-fonts",
+ "kurbo",
+ "pinyin",
+ "read-fonts",
+ "skrifa",
+ "woofwoof",
+ "write-fonts",
+]
 
 [[package]]
 name = "shlex"

Cargo.toml

···
 [package]
 edition = "2024"
-name = "pinyinify"
+name = "rubify"
 version = "0.1.0"
+
+[features]
+default = ["pinyin"]
+pinyin = ["dep:pinyin"]
 
 [dependencies]
 anyhow = "1.0"
 clap = { version = "4.5", features = ["derive"] }
-font-types = "*"
-fontcull = "2.0.0"
-fontcull-font-types = "0.10.2"
-fontcull-klippa = "0.1.2"
-fontcull-read-fonts = "0.38.0"
+font-types = "0.10"
+fontcull = "2.0"
+fontcull-font-types = "0.10"
+fontcull-klippa = "0.1"
+fontcull-read-fonts = "0.38"
 kurbo = "0.12"
-pinyin = "0.11"
+pinyin = { version = "0.11", optional = true }
 read-fonts = { version = "*", features = ["experimental_traverse"] }
-skrifa = "*"
-woofwoof = "1.0.2"
-write-fonts = "*"
+skrifa = "0.39"
+woofwoof = "1.0"
+write-fonts = "0.44"

src/lib.rs

···
 // Imports for subsetting and woff2
 use fontcull_read_fonts as frf;
 use fontcull_read_fonts::collections::int_set::IntSet;
-use kurbo::{Affine, BezPath, Shape};
-use pinyin::ToPinyin;
+use kurbo::BezPath;
 use read_fonts::{
     FileRef, FontRef, TableProvider,
     types::{GlyphId, Tag},
 };
+
+#[cfg(feature = "pinyin")]
+mod ruby;
 use skrifa::{MetadataProvider, outline::OutlinePen};
 use woofwoof;
 use write_fonts::{
···
 const TAG_LOCA: Tag = Tag::new(b"loca");
 const TAG_HEAD: Tag = Tag::new(b"head");
 
-struct PathPen {
-    path: BezPath,
+pub struct PathPen {
+    pub path: BezPath,
 }
 
 impl PathPen {
-    fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             path: BezPath::new(),
         }
···
     process_single_font(font_ref, pinyin_font_ref)
 }
 
-fn process_single_font(font: FontRef, pinyin_font: Option<FontRef>) -> Result<Vec<u8>> {
+fn process_single_font(font: FontRef, _pinyin_font: Option<FontRef>) -> Result<Vec<u8>> {
     let font_file_data = font.table_directory.offset_data();
     let charmap = font.charmap();
     let hmtx = font.hmtx().context("Missing hmtx")?;
···
     let num_glyphs = maxp.num_glyphs();
     let upem = font.head()?.units_per_em() as f64;
 
-    // Providers for pinyin (default to main font)
-    let p_font_ref = pinyin_font.as_ref().unwrap_or(&font);
-    let p_charmap = p_font_ref.charmap();
-    let p_outlines = p_font_ref.outline_glyphs();
-    let p_hmtx = p_font_ref.hmtx().context("Missing pinyin font hmtx")?;
-    let p_upem = p_font_ref.head()?.units_per_em() as f64;
-
-    // Normalizing scale factor:
-    // We want pinyin to be 30% of main font's EM height.
-    // Scale = (0.3 * MainUPEM) / PinyinUPEM
-    let p_scale_factor = (0.3 * upem) / p_upem;
+    #[cfg(feature = "pinyin")]
+    let ruby_renderer: Option<Box<dyn crate::ruby::RubyRenderer>> = {
+        if let Some(pf) = _pinyin_font.as_ref() {
+            match crate::ruby::pinyin::PinyinRenderer::new(pf.clone(), 0.3, upem) {
+                Ok(r) => Some(Box::new(r)),
+                Err(err) => {
+                    eprintln!("Warning: failed to initialize pinyin renderer: {:?}", err);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    };
 
     let mut gid_to_char: HashMap<GlyphId, char> = HashMap::new();
 
···
         }
 
         if let Some(&ch) = gid_to_char.get(&gid) {
-            if let Some(p) = ch.to_pinyin() {
-                let pinyin_text = p.with_tone();
-                let mut pinyin_paths: Vec<(skrifa::GlyphId, BezPath)> = Vec::new();
-                let mut all_found = true;
-
-                for pc in pinyin_text.chars() {
-                    match p_charmap.map(pc) {
-                        Some(pgid) if pgid.to_u32() != 0 => {
-                            if let Some(pglyph) = p_outlines.get(pgid) {
-                                let mut ppen = PathPen::new();
-
-                                if pglyph
-                                    .draw(skrifa::instance::Size::unscaled(), &mut ppen)
-                                    .is_ok()
-                                {
-                                    pinyin_paths.push((pgid, ppen.path));
-                                } else {
-                                    all_found = false;
-
-                                    break;
-                                }
-                            } else {
-                                all_found = false;
-
-                                break;
-                            }
-                        }
-                        _ => {
-                            all_found = false;
-
-                            break;
-                        }
-                    }
-                }
-
-                if all_found && !pinyin_paths.is_empty() {
-                    let orig_advance = hmtx
-                        .h_metrics()
-                        .get(gid.to_u32() as usize)
-                        .map(|m| m.advance.get())
-                        .unwrap_or(upem as u16) as f64;
-
-                    let mut total_pinyin_width = 0.0;
-
-                    for (pgid, _) in &pinyin_paths {
-                        let adv = p_hmtx
-                            .h_metrics()
-                            .get(pgid.to_u32() as usize)
-                            .map(|m| m.advance.get())
-                            .unwrap_or(p_upem as u16) as f64;
-
-                        total_pinyin_width += adv * p_scale_factor;
-                    }
-
-                    let bbox = final_path.bounding_box();
-                    let target_y = bbox.y1 + (upem * 0.1); // 10% EM padding
-                    let mut current_x = (orig_advance - total_pinyin_width) / 2.0;
-
-                    for (pgid, mut p_path) in pinyin_paths {
-                        let adv = p_hmtx
-                            .h_metrics()
-                            .get(pgid.to_u32() as usize)
-                            .map(|m| m.advance.get())
-                            .unwrap_or(p_upem as u16) as f64;
-                        let xform = Affine::translate((current_x, target_y))
-                            * Affine::scale(p_scale_factor);
-
-                        p_path.apply_affine(xform);
-
-                        for el in p_path.elements() {
-                            match el {
-                                kurbo::PathEl::MoveTo(p) => final_path.move_to(*p),
-                                kurbo::PathEl::LineTo(p) => final_path.line_to(*p),
-                                kurbo::PathEl::QuadTo(p1, p2) => final_path.quad_to(*p1, *p2),
-                                kurbo::PathEl::CurveTo(p1, p2, p3) => {
-                                    final_path.curve_to(*p1, *p2, *p3)
-                                }
-                                kurbo::PathEl::ClosePath => final_path.close_path(),
-                            }
-                        }
-
-                        current_x += adv * p_scale_factor;
-                    }
-                }
+            #[cfg(feature = "pinyin")]
+            if let Some(renderer) = &ruby_renderer {
+                let orig_advance = hmtx
+                    .h_metrics()
+                    .get(gid.to_u32() as usize)
+                    .map(|m| m.advance.get())
+                    .unwrap_or(upem as u16) as f64;
+                let _ = renderer.annotate(ch, &mut final_path, orig_advance, upem);
             }
         }
 

src/main.rs

···
     /// Output font file path
     output: PathBuf,
 
-    /// Optional font file to use for pinyin characters
+    /// Optional font file to use for ruby characters
     #[arg(long)]
-    pinyin_font: Option<PathBuf>,
+    ruby_font: Option<PathBuf>,
 
     /// Subset the font to include only CJK and Pinyin characters
     #[arg(long)]
···
     let font_data = fs::read(&cli.input)
         .with_context(|| format!("Failed to read input file: {:?}", cli.input))?;
 
-    let pinyin_font_data = if let Some(path) = &cli.pinyin_font {
-        Some(
-            fs::read(path)
-                .with_context(|| format!("Failed to read pinyin font file: {:?}", path))?,
-        )
+    let ruby_font_data = if let Some(path) = &cli.ruby_font {
+        Some(fs::read(path).with_context(|| format!("Failed to read ruby font file: {:?}", path))?)
     } else {
         None
     };
 
     println!("Processing font...");
-    let mut new_font_data = pinyinify::process_font_file(&font_data, pinyin_font_data.as_deref())?;
+    let mut new_font_data = rubify::process_font_file(&font_data, ruby_font_data.as_deref())?;
 
     if cli.subset {
         println!("Subsetting font...");
-        new_font_data = pinyinify::subset_cjk(&new_font_data)?;
+        new_font_data = rubify::subset_cjk(&new_font_data)?;
     }
 
     // Infer format from output extension
···
 
     if let Some("woff2") = extension.as_deref() {
         println!("Converting to WOFF2...");
-        new_font_data = pinyinify::convert_to_woff2(&new_font_data)?;
+        new_font_data = rubify::convert_to_woff2(&new_font_data)?;
     }
 
     fs::write(&cli.output, new_font_data)

src/ruby/mod.rs

···
+#[cfg(feature = "pinyin")]
+pub mod pinyin;
+
+use anyhow::Result;
+use kurbo::BezPath;
+
+/// A pluggable renderer that can add "ruby" annotations (small text above characters).
+/// Implementations (such as pinyin) will be provided behind features.
+pub trait RubyRenderer: Send + Sync {
+    /// Given a base character `ch`, add annotation paths (if any) into `final_path`.
+    /// `orig_advance` is the glyph advance in font units; `main_upem` is the main font UPEM.
+    fn annotate(
+        &self,
+        ch: char,
+        final_path: &mut BezPath,
+        orig_advance: f64,
+        main_upem: f64,
+    ) -> Result<()>;
+}

src/ruby/pinyin.rs

···
+use ::pinyin::ToPinyin;
+use anyhow::{Context, Result};
+use kurbo::{Affine, BezPath, Shape};
+use read_fonts::{FontRef, TableProvider};
+use skrifa::MetadataProvider;
+
+use crate::{PathPen, ruby::RubyRenderer};
+
+pub struct PinyinRenderer<'a> {
+    font: FontRef<'a>,
+    upem: f64,
+    scale_ratio: f64,
+}
+
+impl<'a> PinyinRenderer<'a> {
+    pub fn new(font: FontRef<'a>, scale_ratio: f64, _main_upem: f64) -> Result<Self> {
+        let upem = font.head()?.units_per_em() as f64;
+
+        Ok(Self {
+            font,
+            upem,
+            scale_ratio,
+        })
+    }
+}
+
+impl<'a> RubyRenderer for PinyinRenderer<'a> {
+    fn annotate(
+        &self,
+        ch: char,
+        final_path: &mut BezPath,
+        orig_advance: f64,
+        main_upem: f64,
+    ) -> Result<()> {
+        if let Some(p) = ch.to_pinyin() {
+            let pinyin_text = p.with_tone();
+            let mut pinyin_paths: Vec<(skrifa::GlyphId, BezPath)> = Vec::new();
+            let mut all_found = true;
+
+            let cmap = self.font.charmap();
+            let outlines = self.font.outline_glyphs();
+            let hmtx = self.font.hmtx().context("Missing pinyin font hmtx")?;
+
+            for pc in pinyin_text.chars() {
+                match cmap.map(pc) {
+                    Some(pgid) if pgid.to_u32() != 0 => {
+                        if let Some(pglyph) = outlines.get(pgid) {
+                            let mut ppen = PathPen::new();
+
+                            if pglyph
+                                .draw(skrifa::instance::Size::unscaled(), &mut ppen)
+                                .is_ok()
+                            {
+                                pinyin_paths.push((pgid, ppen.path));
+                            } else {
+                                all_found = false;
+                                break;
+                            }
+                        } else {
+                            all_found = false;
+                            break;
+                        }
+                    }
+                    _ => {
+                        all_found = false;
+                        break;
+                    }
+                }
+            }
+
+            if all_found && !pinyin_paths.is_empty() {
+                // scale factor relative to the pinyin font's UPEM
+                let p_scale_factor = (self.scale_ratio * main_upem) / self.upem;
+
+                let mut total_pinyin_width = 0.0;
+
+                for (pgid, _) in &pinyin_paths {
+                    let adv = hmtx
+                        .h_metrics()
+                        .get(pgid.to_u32() as usize)
+                        .map(|m| m.advance.get())
+                        .unwrap_or(self.upem as u16) as f64;
+
+                    total_pinyin_width += adv * p_scale_factor;
+                }
+
+                let bbox = final_path.bounding_box();
+                let target_y = bbox.y1 + (main_upem * 0.1); // 10% EM padding
+                let mut current_x = (orig_advance - total_pinyin_width) / 2.0;
+
+                for (pgid, mut p_path) in pinyin_paths {
+                    let adv = hmtx
+                        .h_metrics()
+                        .get(pgid.to_u32() as usize)
+                        .map(|m| m.advance.get())
+                        .unwrap_or(self.upem as u16) as f64;
+
+                    let xform =
+                        Affine::translate((current_x, target_y)) * Affine::scale(p_scale_factor);
+
+                    p_path.apply_affine(xform);
+
+                    for el in p_path.elements() {
+                        match el {
+                            kurbo::PathEl::MoveTo(p) => final_path.move_to(*p),
+                            kurbo::PathEl::LineTo(p) => final_path.line_to(*p),
+                            kurbo::PathEl::QuadTo(p1, p2) => final_path.quad_to(*p1, *p2),
+                            kurbo::PathEl::CurveTo(p1, p2, p3) => {
+                                final_path.curve_to(*p1, *p2, *p3)
+                            }
+                            kurbo::PathEl::ClosePath => final_path.close_path(),
+                        }
+                    }
+
+                    current_x += adv * p_scale_factor;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}