Something went wrong. Try again.
we (web engine): Experimental web browser project to understand the limits of Claude
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308//! CSS resource loading: collect stylesheets from `<link>` and `<style>` elements.//!//! After HTML parsing, this module scans the DOM for stylesheet references,//! fetches external CSS resources, resolves `@import` rules, and merges//! everything into a single `Stylesheet` for style resolution.
use we_css::media::{parse_media_query_list, MediaContext};use we_css::parser::{ ComponentValue, Declaration, FontFaceSourceKind, ImportRule, Parser, Rule, Stylesheet,};use we_css::tokenizer::Tokenizer;use we_dom::{Document, NodeData, NodeId};use we_net::referrer::ReferrerPolicy;use we_url::{Origin, Url};
use crate::loader::{LoadError, Resource, ResourceLoader, ResourceRequestType};
/// Maximum depth for `@import` resolution to prevent cycles.const MAX_IMPORT_DEPTH: usize = 5;
/// Errors that can occur during CSS loading.#[derive(Debug)]pub enum CssLoadError { /// A resource failed to load. Load(LoadError), /// The fetched resource was not CSS. NotCss { url: String },}
impl std::fmt::Display for CssLoadError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Load(e) => write!(f, "CSS load error: {e}"), Self::NotCss { url } => write!(f, "resource at {url} is not CSS"), } }}
impl From<LoadError> for CssLoadError { fn from(e: LoadError) -> Self { Self::Load(e) }}
/// Collect all CSS rules from a parsed DOM document.////// Scans the DOM in document order for `<style>` elements and/// `<link rel="stylesheet">` elements. Inline `<style>` content is parsed/// directly; external stylesheets are fetched via the `ResourceLoader`.////// All rules are merged into a single `Stylesheet` in document order,/// preserving cascade source order. Failed loads are silently skipped/// (graceful degradation).pub fn collect_stylesheets( doc: &Document, loader: &mut ResourceLoader, base_url: &Url,) -> Stylesheet { let document_origin = base_url.origin(); collect_stylesheets_with_origin_and_media(doc, loader, base_url, &document_origin, None)}
/// Collect all CSS rules for a specific viewport.////// This evaluates `<link media>` attributes against the same viewport later/// used by style resolution. It also handles common deferred stylesheet links/// that start as `media="print"` and switch media in an `onload` handler.pub fn collect_stylesheets_for_viewport( doc: &Document, loader: &mut ResourceLoader, base_url: &Url, viewport: (f32, f32),) -> Stylesheet { let document_origin = base_url.origin(); let media_ctx = MediaContext::from_viewport(viewport.0, viewport.1); collect_stylesheets_with_origin_and_media( doc, loader, base_url, &document_origin, Some(&media_ctx), )}
/// Collect all CSS rules with explicit Same-Origin Policy enforcement.pub fn collect_stylesheets_with_origin( doc: &Document, loader: &mut ResourceLoader, base_url: &Url, document_origin: &Origin,) -> Stylesheet { collect_stylesheets_with_origin_and_media(doc, loader, base_url, document_origin, None)}
fn collect_stylesheets_with_origin_and_media( doc: &Document, loader: &mut ResourceLoader, base_url: &Url, document_origin: &Origin, media_ctx: Option<&MediaContext>,) -> Stylesheet { let mut all_rules: Vec<Rule> = Vec::new(); let mut style_nodes = Vec::new(); collect_style_nodes(doc, doc.root(), &mut style_nodes);
for node in style_nodes { match classify_style_node(doc, node) { StyleSource::InlineStyle(css_text) => { let sheet = Parser::parse(&css_text); let resolved = resolve_imports(sheet, loader, base_url, document_origin, 0); all_rules.extend(resolved.rules); } StyleSource::ExternalLink { href, media, referrer_policy, } => { if !media_matches_context(&media, media_ctx) { continue; } match fetch_stylesheet_with_policy( loader, &href, base_url, document_origin, 0, referrer_policy, ) { Ok(sheet) => all_rules.extend(sheet.rules), Err(_) => { // Graceful degradation: skip failed stylesheet loads. } } } StyleSource::NotStylesheet => {} } }
Stylesheet { rules: all_rules }}
/// Walk the DOM in document order and collect `<style>` and `<link>` nodes.fn collect_style_nodes(doc: &Document, node: NodeId, result: &mut Vec<NodeId>) { if let NodeData::Element { tag_name, .. } = doc.node_data(node) { let tag = tag_name.as_str(); if tag.eq_ignore_ascii_case("style") || tag.eq_ignore_ascii_case("link") { result.push(node); } } for child in doc.children(node) { collect_style_nodes(doc, child, result); }}
/// Classification of a DOM node as a style source.enum StyleSource { /// A `<style>` element with inline CSS text. InlineStyle(String), /// A `<link rel="stylesheet">` element with an `href`. ExternalLink { href: String, media: Option<String>, referrer_policy: Option<ReferrerPolicy>, }, /// Not a stylesheet source. NotStylesheet,}
/// Classify a DOM node as a style source.fn classify_style_node(doc: &Document, node: NodeId) -> StyleSource { let tag = match doc.tag_name(node) { Some(t) => t, None => return StyleSource::NotStylesheet, };
if tag.eq_ignore_ascii_case("style") { // Check type attribute — only text/css is valid (or omitted, which defaults to text/css) if let Some(type_attr) = doc.get_attribute(node, "type") { if !type_attr.eq_ignore_ascii_case("text/css") { return StyleSource::NotStylesheet; } } // Collect text content from child text nodes let css_text = collect_text_content(doc, node); StyleSource::InlineStyle(css_text) } else if tag.eq_ignore_ascii_case("link") { // Must have rel="stylesheet" let rel = doc.get_attribute(node, "rel").unwrap_or(""); if !rel .split_ascii_whitespace() .any(|r| r.eq_ignore_ascii_case("stylesheet")) { return StyleSource::NotStylesheet; } // Check type attribute if present if let Some(type_attr) = doc.get_attribute(node, "type") { if !type_attr.eq_ignore_ascii_case("text/css") { return StyleSource::NotStylesheet; } } // Must have href match doc.get_attribute(node, "href") { Some(href) if !href.is_empty() => { let media = effective_stylesheet_media(doc, node); let referrer_policy = doc .get_attribute(node, "referrerpolicy") .and_then(ReferrerPolicy::parse); StyleSource::ExternalLink { href: href.to_string(), media, referrer_policy, } } _ => StyleSource::NotStylesheet, } } else { StyleSource::NotStylesheet }}
fn effective_stylesheet_media(doc: &Document, node: NodeId) -> Option<String> { doc.get_attribute(node, "onload") .and_then(extract_onload_media_assignment) .or_else(|| doc.get_attribute(node, "media").map(|m| m.to_string()))}
fn extract_onload_media_assignment(handler: &str) -> Option<String> { let marker = "this.media"; let start = handler.find(marker)?; let tail = &handler[start + marker.len()..]; let eq = tail.find('=')?; let value = tail[eq + 1..].trim_start(); let quote = value.chars().next()?; if quote != '\'' && quote != '"' { return None; } let after_quote = &value[quote.len_utf8()..]; let end = after_quote.find(quote)?; let media = after_quote[..end].trim(); if media.is_empty() { None } else { Some(media.to_string()) }}
/// Collect concatenated text content from child text nodes of an element.fn collect_text_content(doc: &Document, node: NodeId) -> String { let mut text = String::new(); for child in doc.children(node) { if let Some(data) = doc.text_content(child) { text.push_str(data); } } text}
/// Check if a `media` attribute value matches the `screen` environment.////// Per spec, if no media attribute is present (None), it defaults to `all`./// We support basic media types: `all`, `screen`.fn media_matches(media: &Option<String>) -> bool { match media { None => true, // default is "all" Some(m) => { let m = m.trim(); if m.is_empty() { return true; } // Split comma-separated media types and check if any matches m.split(',').any(|mt| { let mt = mt.trim(); mt.eq_ignore_ascii_case("all") || mt.eq_ignore_ascii_case("screen") }) } }}
fn media_matches_context(media: &Option<String>, ctx: Option<&MediaContext>) -> bool { let Some(ctx) = ctx else { return media_matches(media); }; media_attribute_matches(media.as_deref(), ctx)}
pub(crate) fn media_attribute_matches(media: Option<&str>, ctx: &MediaContext) -> bool { let Some(raw) = media else { return true; }; let raw = raw.trim(); if raw.is_empty() { return true; }
raw.split(',') .any(|query| single_media_query_matches(query.trim(), ctx))}
fn single_media_query_matches(query: &str, ctx: &MediaContext) -> bool { if query.is_empty() { return true; } if starts_with_unknown_media_type(query) { return false; }
let tokens = Tokenizer::tokenize(query); let list = parse_media_query_list(&tokens); !list.queries.is_empty() && list.evaluate(ctx)}
fn starts_with_unknown_media_type(query: &str) -> bool { let trimmed = query.trim_start(); if trimmed.starts_with('(') { return false; }
let first = trimmed .split(|c: char| c.is_ascii_whitespace() || c == '(') .next() .unwrap_or("") .to_ascii_lowercase();
!matches!( first.as_str(), "" | "all" | "screen" | "print" | "not" | "only" )}
/// Fetch an external stylesheet and resolve its `@import` rules.fn fetch_stylesheet( loader: &mut ResourceLoader, href: &str, base_url: &Url, document_origin: &Origin, depth: usize,) -> Result<Stylesheet, CssLoadError> { fetch_stylesheet_with_policy(loader, href, base_url, document_origin, depth, None)}
/// Fetch an external stylesheet with optional element-level referrer policy override.fn fetch_stylesheet_with_policy( loader: &mut ResourceLoader, href: &str, base_url: &Url, document_origin: &Origin, depth: usize, element_policy: Option<ReferrerPolicy>,) -> Result<Stylesheet, CssLoadError> { let url = we_url::Url::parse_with_base(href, base_url) .or_else(|_| we_url::Url::parse(href)) .map_err(|_| CssLoadError::NotCss { url: href.to_string(), })?; let resource = loader.fetch_subresource_with_referrer_policy( &url, document_origin, ResourceRequestType::Stylesheet, element_policy, )?;
let (css_text, resolved_url) = match resource { Resource::Css { text, url } => (text, url), // Some servers may return text/plain or text/html for CSS files. // Accept any text response gracefully. Resource::Html { text, base_url, .. } => (text, base_url), Resource::Other { data, url, .. } => { // Try to decode as UTF-8 text match String::from_utf8(data) { Ok(text) => (text, url), Err(_) => { return Err(CssLoadError::NotCss { url: href.to_string(), }) } } } Resource::Script { text, url } => (text, url), Resource::Image { .. } => { return Err(CssLoadError::NotCss { url: href.to_string(), }) } };
let sheet = Parser::parse(&css_text); Ok(resolve_imports( sheet, loader, &resolved_url, document_origin, depth, ))}
/// Resolve `@import` rules in a stylesheet by fetching and inlining imported sheets.////// Replaces `Rule::Import` entries with the imported stylesheet's rules./// Respects `MAX_IMPORT_DEPTH` to prevent infinite loops.fn resolve_imports( sheet: Stylesheet, loader: &mut ResourceLoader, base_url: &Url, document_origin: &Origin, depth: usize,) -> Stylesheet { if depth >= MAX_IMPORT_DEPTH { // Strip import rules at max depth to prevent cycles return Stylesheet { rules: sheet .rules .into_iter() .filter(|r| !matches!(r, Rule::Import(_))) .map(|r| absolutize_rule_urls(r, base_url)) .collect(), }; }
let mut resolved_rules: Vec<Rule> = Vec::new();
for rule in sheet.rules { match rule { Rule::Import(ImportRule { ref url }) => { match fetch_stylesheet(loader, url, base_url, document_origin, depth + 1) { Ok(imported) => resolved_rules.extend(imported.rules), Err(_) => { // Graceful degradation: skip failed imports. } } } other => resolved_rules.push(absolutize_rule_urls(other, base_url)), } }
Stylesheet { rules: resolved_rules, }}
fn absolutize_rule_urls(rule: Rule, base_url: &Url) -> Rule { match rule { Rule::Style(mut style) => { for decl in &mut style.declarations { absolutize_declaration_urls(decl, base_url); } Rule::Style(style) } Rule::FontFace(mut font_face) => { for source in &mut font_face.sources { if let FontFaceSourceKind::Url(url) = &mut source.source { if let Ok(resolved) = Url::parse_with_base(url, base_url).or_else(|_| Url::parse(url)) { *url = resolved.serialize(); } } } Rule::FontFace(font_face) } Rule::Media(mut media) => { media.rules = media .rules .into_iter() .map(|nested| absolutize_rule_urls(nested, base_url)) .collect(); Rule::Media(media) } Rule::Keyframes(mut keyframes) => { for keyframe in &mut keyframes.keyframes { for decl in &mut keyframe.declarations { absolutize_declaration_urls(decl, base_url); } } Rule::Keyframes(keyframes) } other => other, }}
fn absolutize_declaration_urls(decl: &mut Declaration, base_url: &Url) { for value in &mut decl.value { absolutize_component_urls(value, base_url); }}
fn absolutize_component_urls(value: &mut ComponentValue, base_url: &Url) { if let ComponentValue::Function(name, args) = value { if name.eq_ignore_ascii_case("url") { let non_ws: Vec<usize> = args .iter() .enumerate() .filter_map(|(idx, value)| { (!matches!(value, ComponentValue::Whitespace)).then_some(idx) }) .collect(); if non_ws.len() == 1 { if let ComponentValue::String(url) = &mut args[non_ws[0]] { if let Ok(resolved) = Url::parse_with_base(url, base_url).or_else(|_| Url::parse(url)) { *url = resolved.serialize(); } } } return; }
for arg in args { absolutize_component_urls(arg, base_url); } }}
// ---------------------------------------------------------------------------// Tests// ---------------------------------------------------------------------------
#[cfg(test)]mod tests { use super::*; use we_css::parser::StyleRule;
// ----------------------------------------------------------------------- // Helper: build a DOM manually for testing // -----------------------------------------------------------------------
fn make_doc_with_style(css: &str) -> Document { let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let head = doc.create_element("head"); doc.append_child(html, head);
let style = doc.create_element("style"); doc.append_child(head, style);
let text = doc.create_text(css); doc.append_child(style, text);
let body = doc.create_element("body"); doc.append_child(html, body);
doc }
fn make_doc_with_link(href: &str) -> Document { let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let head = doc.create_element("head"); doc.append_child(html, head);
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", href); doc.append_child(head, link);
let body = doc.create_element("body"); doc.append_child(html, body);
doc }
// ----------------------------------------------------------------------- // collect_style_nodes // -----------------------------------------------------------------------
#[test] fn collects_style_elements() { let doc = make_doc_with_style("body { color: red; }"); let mut nodes = Vec::new(); collect_style_nodes(&doc, doc.root(), &mut nodes); assert_eq!(nodes.len(), 1); assert_eq!(doc.tag_name(nodes[0]), Some("style")); }
#[test] fn collects_link_elements() { let doc = make_doc_with_link("style.css"); let mut nodes = Vec::new(); collect_style_nodes(&doc, doc.root(), &mut nodes); assert_eq!(nodes.len(), 1); assert_eq!(doc.tag_name(nodes[0]), Some("link")); }
#[test] fn collects_both_style_and_link() { let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let head = doc.create_element("head"); doc.append_child(html, head);
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "a.css"); doc.append_child(head, link);
let style = doc.create_element("style"); doc.append_child(head, style); let text = doc.create_text("p { margin: 0; }"); doc.append_child(style, text);
let mut nodes = Vec::new(); collect_style_nodes(&doc, doc.root(), &mut nodes); assert_eq!(nodes.len(), 2); // Document order: link first, then style assert_eq!(doc.tag_name(nodes[0]), Some("link")); assert_eq!(doc.tag_name(nodes[1]), Some("style")); }
#[test] fn ignores_non_style_elements() { let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let body = doc.create_element("body"); doc.append_child(html, body);
let p = doc.create_element("p"); doc.append_child(body, p);
let mut nodes = Vec::new(); collect_style_nodes(&doc, doc.root(), &mut nodes); assert!(nodes.is_empty()); }
// ----------------------------------------------------------------------- // classify_style_node // -----------------------------------------------------------------------
#[test] fn classify_style_element() { let doc = make_doc_with_style("body { color: red; }"); let mut nodes = Vec::new(); collect_style_nodes(&doc, doc.root(), &mut nodes); match classify_style_node(&doc, nodes[0]) { StyleSource::InlineStyle(text) => { assert_eq!(text, "body { color: red; }"); } _ => panic!("expected InlineStyle"), } }
#[test] fn classify_link_stylesheet() { let doc = make_doc_with_link("style.css"); let mut nodes = Vec::new(); collect_style_nodes(&doc, doc.root(), &mut nodes); match classify_style_node(&doc, nodes[0]) { StyleSource::ExternalLink { href, media, .. } => { assert_eq!(href, "style.css"); assert!(media.is_none()); } _ => panic!("expected ExternalLink"), } }
#[test] fn classify_link_with_media() { let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "screen.css"); doc.set_attribute(link, "media", "screen"); doc.append_child(root, link);
match classify_style_node(&doc, link) { StyleSource::ExternalLink { href, media, .. } => { assert_eq!(href, "screen.css"); assert_eq!(media.as_deref(), Some("screen")); } _ => panic!("expected ExternalLink"), } }
#[test] fn classify_link_without_rel_stylesheet() { let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "icon"); doc.set_attribute(link, "href", "favicon.ico"); doc.append_child(root, link);
assert!(matches!( classify_style_node(&doc, link), StyleSource::NotStylesheet )); }
#[test] fn classify_link_without_href() { let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.append_child(root, link);
assert!(matches!( classify_style_node(&doc, link), StyleSource::NotStylesheet )); }
#[test] fn classify_style_wrong_type() { let mut doc = Document::new(); let root = doc.root();
let style = doc.create_element("style"); doc.set_attribute(style, "type", "text/javascript"); doc.append_child(root, style); let text = doc.create_text("not css"); doc.append_child(style, text);
assert!(matches!( classify_style_node(&doc, style), StyleSource::NotStylesheet )); }
#[test] fn classify_style_with_type_text_css() { let mut doc = Document::new(); let root = doc.root();
let style = doc.create_element("style"); doc.set_attribute(style, "type", "text/css"); doc.append_child(root, style); let text = doc.create_text("p { color: blue; }"); doc.append_child(style, text);
match classify_style_node(&doc, style) { StyleSource::InlineStyle(css) => assert_eq!(css, "p { color: blue; }"), _ => panic!("expected InlineStyle"), } }
#[test] fn classify_link_wrong_type() { let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "style.css"); doc.set_attribute(link, "type", "text/plain"); doc.append_child(root, link);
assert!(matches!( classify_style_node(&doc, link), StyleSource::NotStylesheet )); }
// ----------------------------------------------------------------------- // collect_text_content // -----------------------------------------------------------------------
#[test] fn collect_text_single_child() { let mut doc = Document::new(); let root = doc.root();
let style = doc.create_element("style"); doc.append_child(root, style); let text = doc.create_text("body {}"); doc.append_child(style, text);
assert_eq!(collect_text_content(&doc, style), "body {}"); }
#[test] fn collect_text_multiple_children() { let mut doc = Document::new(); let root = doc.root();
let style = doc.create_element("style"); doc.append_child(root, style); let t1 = doc.create_text("body { "); let t2 = doc.create_text("color: red; }"); doc.append_child(style, t1); doc.append_child(style, t2);
assert_eq!(collect_text_content(&doc, style), "body { color: red; }"); }
#[test] fn collect_text_empty_element() { let mut doc = Document::new(); let root = doc.root();
let style = doc.create_element("style"); doc.append_child(root, style);
assert_eq!(collect_text_content(&doc, style), ""); }
// ----------------------------------------------------------------------- // media_matches // -----------------------------------------------------------------------
#[test] fn media_none_matches() { assert!(media_matches(&None)); }
#[test] fn media_empty_matches() { assert!(media_matches(&Some(String::new()))); }
#[test] fn media_all_matches() { assert!(media_matches(&Some("all".to_string()))); }
#[test] fn media_screen_matches() { assert!(media_matches(&Some("screen".to_string()))); }
#[test] fn media_print_does_not_match() { assert!(!media_matches(&Some("print".to_string()))); }
#[test] fn media_comma_list_with_screen() { assert!(media_matches(&Some("print, screen".to_string()))); }
#[test] fn media_comma_list_without_screen() { assert!(!media_matches(&Some("print, handheld".to_string()))); }
#[test] fn media_case_insensitive() { assert!(media_matches(&Some("SCREEN".to_string()))); assert!(media_matches(&Some("All".to_string()))); }
#[test] fn media_attribute_range_matches_viewport() { let ctx = MediaContext::from_viewport(800.0, 600.0); assert!(media_attribute_matches(Some("(min-width: 768px)"), &ctx)); assert!(!media_attribute_matches(Some("(max-width: 767px)"), &ctx)); }
#[test] fn media_attribute_unknown_type_does_not_match() { let ctx = MediaContext::from_viewport(800.0, 600.0); assert!(!media_attribute_matches(Some("handheld"), &ctx)); }
#[test] fn extracts_stylesheet_onload_media_assignment() { assert_eq!( extract_onload_media_assignment("this.media='(min-width: 768px)'; this.onload=null"), Some("(min-width: 768px)".to_string()) ); assert_eq!( extract_onload_media_assignment("this.media=\"all\""), Some("all".to_string()) ); assert_eq!(extract_onload_media_assignment("console.log('x')"), None); }
// ----------------------------------------------------------------------- // collect_stylesheets with inline <style> // -----------------------------------------------------------------------
#[test] fn collect_inline_style_rules() { let doc = make_doc_with_style("p { color: red; } div { margin: 0; }"); let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); assert_eq!(sheet.rules.len(), 2); // Both should be style rules assert!(matches!(sheet.rules[0], Rule::Style(_))); assert!(matches!(sheet.rules[1], Rule::Style(_))); }
#[test] fn collect_empty_style_element() { let doc = make_doc_with_style(""); let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); assert!(sheet.rules.is_empty()); }
#[test] fn collect_multiple_style_elements() { let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let head = doc.create_element("head"); doc.append_child(html, head);
// First <style> let style1 = doc.create_element("style"); doc.append_child(head, style1); let t1 = doc.create_text("p { color: red; }"); doc.append_child(style1, t1);
// Second <style> let style2 = doc.create_element("style"); doc.append_child(head, style2); let t2 = doc.create_text("div { color: blue; }"); doc.append_child(style2, t2);
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); assert_eq!(sheet.rules.len(), 2); }
#[test] fn collect_link_graceful_failure() { // External link will fail to load (no real server), but should not crash let doc = make_doc_with_link("http://nonexistent.test/style.css"); let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); // Should return empty stylesheet (graceful degradation) assert!(sheet.rules.is_empty()); }
#[test] fn link_with_print_media_skipped() { let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let head = doc.create_element("head"); doc.append_child(html, head);
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "print.css"); doc.set_attribute(link, "media", "print"); doc.append_child(head, link);
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); // Print media link should be skipped entirely assert!(sheet.rules.is_empty()); }
#[test] fn deferred_print_stylesheet_onload_media_is_loaded_for_matching_viewport() { let mut doc = Document::new(); let root = doc.root(); let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "data:text/css,p%7Bcolor:red%7D"); doc.set_attribute(link, "media", "print"); doc.set_attribute(link, "onload", "this.media='(min-width: 768px)'"); doc.append_child(root, link);
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap(); let sheet = collect_stylesheets_for_viewport(&doc, &mut loader, &base, (800.0, 600.0)); assert_eq!(sheet.rules.len(), 1); }
#[test] fn deferred_print_stylesheet_onload_media_is_skipped_for_nonmatching_viewport() { let mut doc = Document::new(); let root = doc.root(); let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "data:text/css,p%7Bcolor:red%7D"); doc.set_attribute(link, "media", "print"); doc.set_attribute(link, "onload", "this.media='(min-width: 768px)'"); doc.append_child(root, link);
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap(); let sheet = collect_stylesheets_for_viewport(&doc, &mut loader, &base, (390.0, 844.0)); assert!(sheet.rules.is_empty()); }
// ----------------------------------------------------------------------- // resolve_imports // -----------------------------------------------------------------------
#[test] fn resolve_imports_strips_at_max_depth() { let sheet = Stylesheet { rules: vec![ Rule::Import(ImportRule { url: "deep.css".to_string(), }), Rule::Style(StyleRule { selectors: we_css::parser::SelectorList { selectors: Vec::new(), }, declarations: Vec::new(), }), ], };
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap(); let origin = base.origin();
let resolved = resolve_imports(sheet, &mut loader, &base, &origin, MAX_IMPORT_DEPTH); // Import should be stripped, style rule kept assert_eq!(resolved.rules.len(), 1); assert!(matches!(resolved.rules[0], Rule::Style(_))); }
#[test] fn resolve_imports_failed_import_skipped() { let sheet = Stylesheet { rules: vec![ Rule::Import(ImportRule { url: "http://nonexistent.test/import.css".to_string(), }), Rule::Style(StyleRule { selectors: we_css::parser::SelectorList { selectors: Vec::new(), }, declarations: Vec::new(), }), ], };
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap(); let origin = base.origin();
let resolved = resolve_imports(sheet, &mut loader, &base, &origin, 0); // Failed import should be skipped, style rule kept assert_eq!(resolved.rules.len(), 1); assert!(matches!(resolved.rules[0], Rule::Style(_))); }
#[test] fn resolve_imports_absolutizes_font_face_urls_against_stylesheet_url() { let sheet = Parser::parse( r#" @media screen { @font-face { font-family: Inter; src: local("Arial"), url("../fonts/inter.woff") format("woff"); } } "#, );
let mut loader = ResourceLoader::new(); let base = Url::parse("https://cdn.example.com/static/css/main.css").unwrap(); let origin = base.origin();
let resolved = resolve_imports(sheet, &mut loader, &base, &origin, 0); let Rule::Media(media) = &resolved.rules[0] else { panic!("expected media rule"); }; let Rule::FontFace(font_face) = &media.rules[0] else { panic!("expected font-face rule"); };
assert_eq!( font_face.sources[0].source, FontFaceSourceKind::Local("Arial".to_string()) ); assert_eq!( font_face.sources[1].source, FontFaceSourceKind::Url("https://cdn.example.com/static/fonts/inter.woff".to_string()) ); }
#[test] fn resolve_imports_absolutizes_style_rule_urls_against_stylesheet_url() { let sheet = Parser::parse( r#" .download-button::before { background-image: url("../icons/mac.svg"); } "#, );
let mut loader = ResourceLoader::new(); let base = Url::parse("https://cdn.example.com/static/css/main.css").unwrap(); let origin = base.origin();
let resolved = resolve_imports(sheet, &mut loader, &base, &origin, 0); let Rule::Style(style) = &resolved.rules[0] else { panic!("expected style rule"); }; let ComponentValue::Function(name, args) = &style.declarations[0].value[0] else { panic!("expected url() function"); };
assert_eq!(name, "url"); assert_eq!( args, &vec![ComponentValue::String( "https://cdn.example.com/static/icons/mac.svg".to_string() )] ); }
#[test] fn resolve_imports_absolutizes_urls_inside_custom_properties() { let sheet = Parser::parse( r#" :root { --mac-download-logo: url("../icons/mac.svg"); } .download-button::before { background-image: var(--mac-download-logo); } "#, );
let mut loader = ResourceLoader::new(); let base = Url::parse("https://cdn.example.com/static/css/main.css").unwrap(); let origin = base.origin();
let resolved = resolve_imports(sheet, &mut loader, &base, &origin, 0); let Rule::Style(style) = &resolved.rules[0] else { panic!("expected style rule"); }; let ComponentValue::Function(name, args) = &style.declarations[0].value[0] else { panic!("expected url() function"); };
assert_eq!(name, "url"); assert_eq!( args, &vec![ComponentValue::String( "https://cdn.example.com/static/icons/mac.svg".to_string() )] ); }
// ----------------------------------------------------------------------- // CssLoadError display // -----------------------------------------------------------------------
#[test] fn css_load_error_display_not_css() { let e = CssLoadError::NotCss { url: "test.png".to_string(), }; assert_eq!(e.to_string(), "resource at test.png is not CSS"); }
#[test] fn css_load_error_display_load() { let e = CssLoadError::Load(LoadError::InvalidUrl("bad".to_string())); assert!(e.to_string().contains("CSS load error")); }
// ----------------------------------------------------------------------- // Integration: style + link document order // -----------------------------------------------------------------------
#[test] fn style_and_link_document_order() { // When both <style> and <link> are present, inline styles should be // collected in document order (link will fail but style should work) let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let head = doc.create_element("head"); doc.append_child(html, head);
// Link first (will fail) let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "http://nonexistent.test/first.css"); doc.append_child(head, link);
// Style second let style = doc.create_element("style"); doc.append_child(head, style); let text = doc.create_text("p { color: green; }"); doc.append_child(style, text);
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); // Only the inline style should succeed assert_eq!(sheet.rules.len(), 1); }
// ----------------------------------------------------------------------- // Edge cases // -----------------------------------------------------------------------
#[test] fn link_with_empty_href_skipped() { let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", ""); doc.append_child(root, link);
assert!(matches!( classify_style_node(&doc, link), StyleSource::NotStylesheet )); }
#[test] fn style_in_body_is_collected() { // <style> in <body> should also be collected (browsers allow this) let mut doc = Document::new(); let root = doc.root();
let html = doc.create_element("html"); doc.append_child(root, html);
let body = doc.create_element("body"); doc.append_child(html, body);
let style = doc.create_element("style"); doc.append_child(body, style); let text = doc.create_text("h1 { font-size: 2em; }"); doc.append_child(style, text);
let mut loader = ResourceLoader::new(); let base = Url::parse("http://example.com/").unwrap();
let sheet = collect_stylesheets(&doc, &mut loader, &base); assert_eq!(sheet.rules.len(), 1); }
#[test] fn link_rel_case_insensitive() { // rel="Stylesheet" should work too (case-insensitive matching) let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "Stylesheet"); doc.set_attribute(link, "href", "style.css"); doc.append_child(root, link);
match classify_style_node(&doc, link) { StyleSource::ExternalLink { href, .. } => assert_eq!(href, "style.css"), _ => panic!("expected ExternalLink"), } }
#[test] fn link_rel_with_extra_values() { // rel="alternate stylesheet" should NOT match as a regular stylesheet // (alternate stylesheets are disabled by default) // Actually, per spec, "stylesheet" in the token list means it IS a stylesheet // But "alternate stylesheet" is a disabled stylesheet. For simplicity, // we treat any rel containing "stylesheet" as a stylesheet. let mut doc = Document::new(); let root = doc.root();
let link = doc.create_element("link"); doc.set_attribute(link, "rel", "stylesheet"); doc.set_attribute(link, "href", "style.css"); doc.append_child(root, link);
assert!(matches!( classify_style_node(&doc, link), StyleSource::ExternalLink { .. } )); }}