fontbe 0.5.0

the backend for fontc, a font compiler.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Helpers for testing layout code

use std::{collections::HashSet, path::Path, sync::Arc};

use fea_rs::compile::{Compilation, FeatureProvider};
use fontdrasil::{coords::NormalizedLocation, types::Axes};
use fontir::ir::{GdefCategories, GlyphOrder, NamedInstance, StaticMetadata};

use crate::orchestration::FeaFirstPassOutput;

use super::FeaVariationInfo;

/// A builder for constructing  [`LayoutOutput`]
pub(crate) struct LayoutOutputBuilder {
    axes: Axes,
    categories: Option<GdefCategories>,
    named_instances: Vec<NamedInstance>,
    glyph_locations: HashSet<NormalizedLocation>,
    user_fea: Arc<str>,
    glyph_order: GlyphOrder,
}

/// A helper for compiling layout tables (including with user-provided features)
pub(crate) struct LayoutOutput {
    pub(crate) static_metadata: StaticMetadata,
    pub(crate) glyph_order: GlyphOrder,
    pub(crate) first_pass_fea: FeaFirstPassOutput,
}

impl LayoutOutputBuilder {
    pub(crate) fn new() -> Self {
        Default::default()
    }

    pub(crate) fn with_axes(&mut self, axes: Axes) -> &mut Self {
        self.axes = axes;
        self
    }

    pub(crate) fn with_categories(&mut self, categories: GdefCategories) -> &mut Self {
        self.categories = categories.into();
        self
    }

    pub(crate) fn with_instances(&mut self, instances: Vec<NamedInstance>) -> &mut Self {
        self.named_instances = instances;
        self
    }

    pub(crate) fn with_locations(&mut self, locations: HashSet<NormalizedLocation>) -> &mut Self {
        self.glyph_locations = locations;
        self
    }

    pub(crate) fn with_user_fea(&mut self, user_fea: &str) -> &mut Self {
        self.user_fea = user_fea.into();
        self
    }

    pub(crate) fn with_glyph_order(&mut self, glyph_order: GlyphOrder) -> &mut Self {
        self.glyph_order = glyph_order;
        self
    }

    pub(crate) fn build(&self) -> LayoutOutput {
        let static_metadata = StaticMetadata::new(
            1000,
            Default::default(),
            self.axes.clone().into_inner(),
            self.named_instances.clone(),
            self.glyph_locations.clone(),
            Default::default(),
            42.0,
            self.categories.clone().unwrap_or_default(),
            None,
            false,
        )
        .unwrap();

        let glyph_map = self.glyph_order.names().cloned().collect();
        // first get the AST, which we need to use as input
        let fea = self.user_fea.clone();
        let (ast, _) = fea_rs::parse::parse_root(
            "memory".into(),
            Some(&glyph_map),
            Box::new(move |x: &Path| {
                if x == Path::new("memory") {
                    Ok(fea.clone())
                } else {
                    unreachable!("our FEA has no include statements");
                }
            }),
        )
        .unwrap();

        let first_pass_fea = FeaFirstPassOutput::for_test(ast, &glyph_map).unwrap();
        LayoutOutput {
            static_metadata,
            glyph_order: self.glyph_order.clone(),
            first_pass_fea,
        }
    }
}

impl LayoutOutput {
    pub(crate) fn compile(&self, feature_writer: &impl FeatureProvider) -> Compilation {
        let var_info = FeaVariationInfo::new(&self.static_metadata);
        let glyph_map = self.glyph_order.names().cloned().collect();
        fea_rs::compile::compile(
            &self.first_pass_fea.ast,
            &glyph_map,
            Some(&var_info),
            Some(feature_writer),
            Default::default(),
        )
        .unwrap()
        .0
    }
}

impl Default for LayoutOutputBuilder {
    fn default() -> Self {
        Self {
            axes: Default::default(),
            categories: None,
            named_instances: Default::default(),
            glyph_locations: Default::default(),
            user_fea: "languagesystem DFLT dflt;".into(),
            glyph_order: Default::default(),
        }
    }
}