fea-rs 1.0.0

Tools for working with Adobe OpenType Feature files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Building the `Debg` debug table.
//!
//! The `Debg` table stores source-level information about each lookup,
//! compatible with the [fontTools feaLib implementation][feaLib], but unlike
//! feaLib, we always set feature to null.
//!
//! [feaLib]: https://github.com/fonttools/fonttools/blob/bb1109e9/Lib/fontTools/feaLib/builder.py#L860-L864
//!
//! Format: raw UTF-8 JSON with the schema:
//! ```json
//! {
//!   "com.github.fonttools.feaLib": {
//!     "GSUB": { "0": ["file.fea:4:5", "lookup_name", null] },
//!     "GPOS": { "0": ["file.fea:8:1", null, null] }
//!   }
//! }
//! ```

use std::ops::Range;

use smol_str::SmolStr;

use crate::parse::ParseTree;
use write_fonts::types::Tag;

/// The 4-byte tag for the Debg table.
pub(crate) const DEBG_TAG: Tag = Tag::new(b"Debg");

/// The top-level key used in the Debg JSON.
const LOOKUP_DEBUG_INFO_KEY: &str = "com.github.fonttools.feaLib";

/// Debug information for a single lookup.
///
/// Stores the global source range and optional name; resolved to
/// `"file:line:col"` when building the final Debg bytes.
#[derive(Debug, Clone)]
pub(crate) struct LookupDebugInfo {
    pub range: Range<usize>,
    pub name: Option<SmolStr>,
}

/// Builder for the `Debg` table.
#[derive(Clone, Debug)]
pub(crate) struct DebgBuilder {
    gsub: Vec<Option<LookupDebugInfo>>,
    gpos: Vec<Option<LookupDebugInfo>>,
}

impl DebgBuilder {
    pub(crate) fn new(
        gsub: Vec<Option<LookupDebugInfo>>,
        gpos: Vec<Option<LookupDebugInfo>>,
    ) -> Self {
        Self { gsub, gpos }
    }

    pub(crate) fn build(&self, tree: &ParseTree) -> Vec<u8> {
        let mut out = String::new();
        out.push_str(&format!("{{\"{LOOKUP_DEBUG_INFO_KEY}\":{{"));

        let tables: Vec<_> = [("GSUB", &self.gsub), ("GPOS", &self.gpos)]
            .into_iter()
            .filter(|(_, infos)| infos.iter().any(|i| i.is_some()))
            .map(|(tag, infos)| {
                let entries: Vec<_> = infos
                    .iter()
                    .enumerate()
                    .filter_map(|(idx, info)| {
                        let info = info.as_ref()?;
                        let (file_id, local_range) =
                            tree.source_map().resolve_range(info.range.clone());
                        let location = tree
                            .get_source(file_id)
                            .map(|source| {
                                let (line, col) = source.line_col_for_offset(local_range.start);
                                format!("\"{}:{line}:{col}\"", source.path().display())
                            })
                            .unwrap_or_default();
                        let name = match &info.name {
                            Some(s) => format!("\"{s}\""),
                            None => "null".into(),
                        };
                        Some(format!("\"{idx}\":[{location},{name},null]"))
                    })
                    .collect();
                format!("\"{tag}\":{{{}}}", entries.join(","))
            })
            .collect();
        out.push_str(&tables.join(","));

        out.push_str("}}");
        out.into_bytes()
    }
}