Files
moli/moli-css-parse/src/font_face.rs
T

477 lines
16 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use cssparser::{Parser, Token};
use style::{
font_face::Source,
moli_font_face::{parse_font_face_source_list, supports_font_source},
};
use crate::unquote_css_string;
pub use style::moli_font_face::{CssFontFace, normalize_font_face_src, parse_font_faces};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CssFontSource {
Local(String),
Url(String),
}
/// Parse font sources in fallback order, leaving URL resolution to the caller.
pub fn parse_font_face_sources(source: &str) -> Option<Vec<CssFontSource>> {
let sources = parse_font_face_source_list(source)?;
Some(
sources
.0
.into_iter()
.filter_map(|source| match source {
Source::Local(name) => Some(CssFontSource::Local(name.name.to_string())),
Source::Url(source) => supports_font_source(&source)
.then(|| CssFontSource::Url(source.url.as_specified_str().to_owned())),
})
.collect(),
)
}
/// A decoded family name or a generic selected by the CSS parser. Quoting a
/// generic keyword makes it a named family rather than a generic fallback.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CssFontFamily {
Named(String),
Generic(style::values::computed::font::GenericFontFamily),
}
/// A CSS font-family lookup key matching Blink's case-folding hash: Unicode
/// simple folding of UTF-16 code units, without normalization or locale tailoring.
/// This is separate from platform local() full-name lookup.
pub fn font_family_name_key(name: &str) -> String {
if name.is_ascii() {
return name.to_ascii_lowercase();
}
name.chars()
.map(|character| {
// Blink hashes each UTF-16 code unit; surrogate pairs do not fold.
if character.len_utf16() == 2 {
return character;
}
unicode_case_mapping::case_folded(character)
.and_then(|folded| char::from_u32(folded.get()))
.unwrap_or(character)
})
.collect()
}
#[derive(Clone, Debug)]
pub struct CssFontShorthand {
pub family_css: String,
pub families: Vec<CssFontFamily>,
pub size: String,
pub style: String,
pub weight: String,
pub stretch: String,
}
/// Shares the CSS font grammar with style declarations, including quoted
/// multi-word families and fallback lists. No guessed last-whitespace token.
pub fn parse_font_shorthand(value: &str) -> Option<CssFontShorthand> {
use style::{
parser::Parse,
properties::{PropertyId, parse_property_declaration_list},
stylesheets::CssRuleType,
values::computed::font::SingleFontFamily,
};
use style_traits::CssStringWriter;
if crate::escape_top_level_semicolons(value) != value
|| crate::split_important_priority(value).1
{
return None;
}
crate::stylo_stylesheet::with_descriptor_declaration_context(CssRuleType::Style, |context| {
let text = format!("font: {value}");
let block = parse_property_declaration_list(context, &mut Parser::new(&text), &[]);
let property = |name: &str| -> Option<String> {
let mut out = CssStringWriter::new();
block
.property_value_to_css(&PropertyId::parse(name, context).ok()?, &mut out)
.ok()?;
(!out.is_empty()).then(|| out.to_string())
};
let family_css = property("font-family")?;
let size = property("font-size")?;
if is_css_wide_keyword(&size) || size.contains("var(") {
return None;
}
let families = Parser::new(&family_css)
.parse_comma_separated(|p| {
SingleFontFamily::parse(context, p).map(|family| match family {
SingleFontFamily::FamilyName(name) => {
CssFontFamily::Named(name.name.to_string())
}
SingleFontFamily::Generic(generic) => CssFontFamily::Generic(generic),
})
})
.ok()?;
Some(CssFontShorthand {
family_css,
families,
size,
style: property("font-style")?,
weight: property("font-weight")?,
stretch: property("font-stretch")?,
})
})
}
pub fn font_load_query_contains_css_wide_keyword(query: &str) -> bool {
let input = query;
let mut input = Parser::new(input);
while let Ok(token) = input.next() {
match token {
Token::Ident(value)
if is_css_wide_keyword(value.as_ref()) || value.eq_ignore_ascii_case("default") =>
{
return true;
}
_ => {}
}
}
false
}
/// FontFaceSet queries use the font shorthand grammar, without cascade or
/// custom-property substitution. Keep parsing shared with CSS declarations.
pub fn font_load_query_is_valid(query: &str) -> bool {
// Servo's Stylo configuration does not parse system fonts. Their entire
// shorthand syntax is one of these six identifiers; use CSS tokens so
// escapes, comments and case folding work without accepting trailing input.
let input = query;
let mut parser = Parser::new(input);
if let Ok(name) = parser.expect_ident_cloned()
&& matches!(
name.to_ascii_lowercase().as_str(),
"caption" | "icon" | "menu" | "message-box" | "small-caption" | "status-bar"
)
&& parser.is_exhausted()
{
return true;
}
if font_load_query_contains_css_wide_keyword(query) {
return false;
}
let mut block = crate::CssDeclarationBlock::default();
let projection = block.set_property_with_projection("font", query, false);
projection.set_result != crate::CssSetResult::ParseError
&& !projection.has_unresolved_value
&& !block.is_empty()
}
pub fn font_load_query_family(query: &str) -> Option<String> {
let trimmed = query.trim();
if trimmed.is_empty() {
return None;
}
let mut quote = None;
let mut last_ws = None;
for (index, ch) in trimmed.char_indices() {
match ch {
'\'' | '"' if quote == Some(ch) => quote = None,
'\'' | '"' if quote.is_none() => quote = Some(ch),
_ if quote.is_none() && ch.is_whitespace() => last_ws = Some(index),
_ => {}
}
}
let family = last_ws
.map(|index| trimmed[index..].trim())
.unwrap_or(trimmed);
Some(unquote_css_string(family))
}
fn is_css_wide_keyword(value: &str) -> bool {
matches!(
value.to_ascii_lowercase().as_str(),
"inherit" | "initial" | "unset" | "revert" | "revert-layer" | "revert-rule"
)
}
#[cfg(test)]
mod tests {
#[test]
fn font_name_keys_follow_chromium_case_folding_without_expansion_or_normalization() {
use super::font_family_name_key;
for (a, b) in [
("Äpfel", "äpfel"),
("Σπίτι", "σπίτι"),
("ΟΣ", "ος"),
("K", "k"),
("ẞ", "ß"),
("µ", "Μ"),
] {
assert_eq!(
font_family_name_key(a),
font_family_name_key(b),
"{a} / {b}"
);
}
for (a, b) in [
("Straße", "STRASSE"),
("Å", "A\u{030a}"),
("İ", "i"),
("İ", "i\u{0307}"),
("𐐀", "𐐨"),
] {
assert_ne!(
font_family_name_key(a),
font_family_name_key(b),
"{a} / {b}"
);
}
}
#[test]
fn font_sources_preserve_local_names_and_supported_url_fallback_order() {
use super::*;
assert_eq!(
parse_font_face_sources(
"local(Missing Font), url(bad) format('unsupported'), url(good.woff2) format('woff2')"
),
Some(vec![
CssFontSource::Local("Missing Font".into()),
CssFontSource::Url("good.woff2".into())
])
);
assert!(parse_font_face_sources("not a source").is_none());
}
#[test]
fn font_sources_accept_legacy_variable_formats_and_keep_unknown_fallbacks() {
use super::*;
for format in [
"woff-variations",
"woff2-variations",
"truetype-variations",
"opentype-variations",
] {
assert_eq!(
parse_font_face_sources(&format!("url(variable) format('{format}')")),
Some(vec![CssFontSource::Url("variable".into())]),
);
}
assert_eq!(
parse_font_face_sources(
"url(unknown) format('svg-variations'), url(empty) format(), url(fallback) format('woff2')"
),
Some(vec![CssFontSource::Url("fallback".into())]),
);
}
#[test]
fn font_sources_filter_hints_using_renderer_capabilities() {
use super::*;
assert_eq!(
parse_font_face_sources(
r#"url(legacy) format('embedded-opentype'),
url(svg-color) format(woff2) tech(variations, color-svg),
url("fonts/Variable Font.woff2") format(WOFF2) tech(variations, features-opentype),
url(aat.woff2) format(woff2) tech(features-aat),
url(fallback) format("OTF")"#
),
Some(vec![
CssFontSource::Url("fonts/Variable Font.woff2".into()),
CssFontSource::Url("aat.woff2".into()),
CssFontSource::Url("fallback".into()),
])
);
}
#[test]
fn font_shorthand_distinguishes_quoted_and_escaped_generic_keywords() {
use super::{CssFontFamily, parse_font_shorthand};
use style::values::computed::font::GenericFontFamily;
for keyword in ["serif", "SeRiF", r"s\65 rif"] {
let font = parse_font_shorthand(&format!("16px {keyword}")).unwrap();
assert_eq!(
font.families,
[CssFontFamily::Generic(GenericFontFamily::Serif)]
);
}
for name in [r#""serif""#, r#""s\65 rif""#, "Named serif"] {
let font = parse_font_shorthand(&format!("16px {name}")).unwrap();
let expected = if name == "Named serif" {
"Named serif"
} else {
"serif"
};
assert_eq!(font.families, [CssFontFamily::Named(expected.into())]);
}
}
#[test]
fn font_shorthand_uses_stylo_validation_and_keeps_all_families() {
let font =
super::parse_font_shorthand("italic bold 10.5px/1.2 \"A B\", Another Face, serif")
.unwrap();
assert_eq!(
font.families,
[
super::CssFontFamily::Named("A B".into()),
super::CssFontFamily::Named("Another Face".into()),
super::CssFontFamily::Generic(
style::values::computed::font::GenericFontFamily::Serif
),
]
);
assert_eq!(font.size, "10.5px");
assert_eq!(font.style, "italic");
for invalid in [
"",
"12px",
"not a font",
"inherit",
"12px serif; color:red",
"12px serif !important",
] {
assert!(super::parse_font_shorthand(invalid).is_none(), "{invalid}");
}
}
use super::{
font_load_query_contains_css_wide_keyword, font_load_query_family,
font_load_query_is_valid, normalize_font_face_src, parse_font_faces,
};
#[test]
fn font_face_parser_uses_cssparser_rule_boundaries() {
let entries = parse_font_faces(
r#"
.ignored { content: "@font-face { font-family: Bad; src: url(bad.woff2); }"; }
@font-face {
font-family: "A; B";
src: url("data:font/woff2;base64;a;b");
}
@FONT-FACE {
font-family: CaseFace;
src: local("Case Face");
}
"#,
);
assert_eq!(entries.len(), 2);
assert_eq!(entries[0].family, "A; B");
assert_eq!(entries[0].source, r#"url("data:font/woff2;base64;a;b")"#);
assert_eq!(entries[1].family, "CaseFace");
assert_eq!(entries[1].source, r#"local("Case Face")"#);
}
#[test]
fn font_face_parser_filters_invalid_and_incomplete_faces() {
let entries = parse_font_faces(
r#"
@font-face { font-family: serif; src: url(generic.woff2); }
@font-face { font-family: MissingSource; }
@font-face { src: url(missing-family.woff2); }
@font-face { font-family: Valid; src: url(valid.woff2); }
"#,
);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].family, "Valid");
assert_eq!(entries[0].source, r#"url("valid.woff2")"#);
}
#[test]
fn font_face_src_normalizer_quotes_unquoted_urls() {
assert_eq!(
normalize_font_face_src("local(STIXGeneral), url(/stixfonts/STIXGeneral.otf)")
.as_deref(),
Some(r#"local(STIXGeneral), url("/stixfonts/STIXGeneral.otf")"#)
);
assert_eq!(
normalize_font_face_src("url(http://foo/bar/font.ttf)").as_deref(),
Some(r#"url("http://foo/bar/font.ttf")"#)
);
}
#[test]
fn font_load_query_validates_the_complete_shorthand_without_substitution() {
for query in [
"",
"inherit",
"default",
"12px inherit",
"12px default",
r#""inherit""#,
"12px",
"serif",
"12px serif; color: red",
"-1px serif",
"var(--x) serif",
"var(--x, 10px) serif",
"env(size) serif",
"12px serif !important",
"12px serif,",
"caption garbage",
r#""caption""#,
] {
assert!(!font_load_query_is_valid(query), "{query}");
}
for query in [
"12px serif",
r#"12px "inherit""#,
r#"12px "default""#,
r#"italic 700 16px/1.2 "A B", serif"#,
"calc(1em + 2px) serif",
"caption",
"ICON",
"menu",
"message-box",
"small-caption",
"status-bar",
r"c\61 ption",
"caption/**/",
"normal normal normal normal 12px serif",
] {
assert!(font_load_query_is_valid(query), "{query}");
}
}
#[test]
fn font_load_query_distinguishes_reserved_identifiers_from_quoted_families() {
for keyword in [
"inherit",
"initial",
"unset",
"default",
"revert",
"revert-layer",
] {
for query in [keyword.to_owned(), format!("medium {keyword}")] {
assert!(font_load_query_contains_css_wide_keyword(&query), "{query}");
}
for query in [format!("12px \"{keyword}\""), format!("12px '{keyword}'")] {
assert!(
!font_load_query_contains_css_wide_keyword(&query),
"{query}"
);
}
}
assert!(font_load_query_contains_css_wide_keyword(
r"12px \64 efault"
));
assert!(!font_load_query_contains_css_wide_keyword(
r#"12px "\69 nherit""#
));
}
#[test]
fn font_load_query_uses_css_tokens_for_family_and_keywords() {
assert!(font_load_query_contains_css_wide_keyword(
r#"italic 16px inherit"#
));
assert!(!font_load_query_contains_css_wide_keyword(
r#"16px "inheritance""#
));
assert_eq!(
font_load_query_family(r#"italic small-caps bold 16px/2 "A B", serif"#).as_deref(),
Some("serif")
);
assert_eq!(
font_load_query_family(r#""Standalone Family""#).as_deref(),
Some("Standalone Family")
);
}
}