mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
477 lines
16 KiB
Rust
477 lines
16 KiB
Rust
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")
|
||
);
|
||
}
|
||
}
|