Something went wrong. Try again.
we (web engine): Experimental web browser project to understand the limits of Claude
Something went wrong. Try again.
Rust
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348//! CSS value parsing: convert raw component values into typed property values.//!//! Provides `CssValue` enum and parsing from `ComponentValue` lists.
use crate::parser::ComponentValue;
// ---------------------------------------------------------------------------// Core value types// ---------------------------------------------------------------------------
/// A fully parsed, typed CSS value.#[derive(Debug, Clone, PartialEq)]pub enum CssValue { /// A length with resolved unit. Length(f64, LengthUnit), /// A percentage value. Percentage(f64), /// A color value (r, g, b, a in 0–255 range, alpha 0–255). Color(Color), /// A numeric value (unitless). Number(f64), /// A string value. String(String), /// A keyword (ident). Keyword(String), /// The `auto` keyword. Auto, /// The `inherit` keyword. Inherit, /// The `initial` keyword. Initial, /// The `unset` keyword. Unset, /// The `currentColor` keyword. CurrentColor, /// The `none` keyword (for display, background, etc.). None, /// The `transparent` keyword. Transparent, /// Zero (unitless). Zero, /// A list of values (for multi-value properties like margin shorthand). List(Vec<CssValue>),}
/// CSS length unit.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum LengthUnit { // Absolute Px, Pt, Cm, Mm, In, Pc, // Font-relative Em, Rem, // Viewport Vw, Vh, Vmin, Vmax,}
/// A CSS color in RGBA format.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct Color { pub r: u8, pub g: u8, pub b: u8, pub a: u8,}
impl Color { pub fn new(r: u8, g: u8, b: u8, a: u8) -> Self { Self { r, g, b, a } }
pub fn rgb(r: u8, g: u8, b: u8) -> Self { Self { r, g, b, a: 255 } }}
// ---------------------------------------------------------------------------// Shorthand expansion result// ---------------------------------------------------------------------------
/// A longhand property-value pair produced by shorthand expansion.#[derive(Debug, Clone, PartialEq)]pub struct LonghandDeclaration { pub property: String, pub value: CssValue, pub important: bool,}
// ---------------------------------------------------------------------------// Value parsing// ---------------------------------------------------------------------------
/// Parse a single `CssValue` from a list of component values.pub fn parse_value(values: &[ComponentValue]) -> CssValue { // Filter out whitespace for easier matching let non_ws: Vec<&ComponentValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace)) .collect();
if non_ws.is_empty() { return CssValue::Keyword(String::new()); }
// Single-value case if non_ws.len() == 1 { return parse_single_value(non_ws[0]); }
// Multi-value: parse each non-whitespace value let parsed: Vec<CssValue> = non_ws.iter().copied().map(parse_single_value).collect(); CssValue::List(parsed)}
/// Parse a single component value into a `CssValue`.pub fn parse_single_value(cv: &ComponentValue) -> CssValue { match cv { ComponentValue::Ident(s) => parse_keyword(s), ComponentValue::String(s) => CssValue::String(s.clone()), ComponentValue::Number(n, _) => { if *n == 0.0 { CssValue::Zero } else { CssValue::Number(*n) } } ComponentValue::Percentage(n) => CssValue::Percentage(*n), ComponentValue::Dimension(n, _, unit) => parse_dimension(*n, unit), ComponentValue::Hash(s, _) => parse_hex_color(s), ComponentValue::Function(name, args) => parse_function(name, args), ComponentValue::Comma => CssValue::Keyword(",".to_string()), ComponentValue::Delim(c) => CssValue::Keyword(c.to_string()), ComponentValue::Whitespace => CssValue::Keyword(" ".to_string()), }}
fn parse_keyword(s: &str) -> CssValue { match s.to_ascii_lowercase().as_str() { "auto" => CssValue::Auto, "inherit" => CssValue::Inherit, "initial" => CssValue::Initial, "unset" => CssValue::Unset, "none" => CssValue::None, "transparent" => CssValue::Transparent, "currentcolor" => CssValue::CurrentColor, // Named colors name => { if let Some(color) = named_color(name) { CssValue::Color(color) } else { CssValue::Keyword(s.to_ascii_lowercase()) } } }}
fn parse_dimension(n: f64, unit: &str) -> CssValue { let u = unit.to_ascii_lowercase(); match u.as_str() { "px" => CssValue::Length(n, LengthUnit::Px), "pt" => CssValue::Length(n, LengthUnit::Pt), "cm" => CssValue::Length(n, LengthUnit::Cm), "mm" => CssValue::Length(n, LengthUnit::Mm), "in" => CssValue::Length(n, LengthUnit::In), "pc" => CssValue::Length(n, LengthUnit::Pc), "em" => CssValue::Length(n, LengthUnit::Em), "rem" => CssValue::Length(n, LengthUnit::Rem), "vw" => CssValue::Length(n, LengthUnit::Vw), "vh" => CssValue::Length(n, LengthUnit::Vh), "vmin" => CssValue::Length(n, LengthUnit::Vmin), "vmax" => CssValue::Length(n, LengthUnit::Vmax), _ => CssValue::Keyword(format!("{n}{u}")), }}
// ---------------------------------------------------------------------------// Color parsing// ---------------------------------------------------------------------------
fn parse_hex_color(hex: &str) -> CssValue { let chars: Vec<char> = hex.chars().collect(); match chars.len() { // #rgb 3 => { let r = hex_digit(chars[0]) * 17; let g = hex_digit(chars[1]) * 17; let b = hex_digit(chars[2]) * 17; CssValue::Color(Color::rgb(r, g, b)) } // #rgba 4 => { let r = hex_digit(chars[0]) * 17; let g = hex_digit(chars[1]) * 17; let b = hex_digit(chars[2]) * 17; let a = hex_digit(chars[3]) * 17; CssValue::Color(Color::new(r, g, b, a)) } // #rrggbb 6 => { let r = hex_byte(chars[0], chars[1]); let g = hex_byte(chars[2], chars[3]); let b = hex_byte(chars[4], chars[5]); CssValue::Color(Color::rgb(r, g, b)) } // #rrggbbaa 8 => { let r = hex_byte(chars[0], chars[1]); let g = hex_byte(chars[2], chars[3]); let b = hex_byte(chars[4], chars[5]); let a = hex_byte(chars[6], chars[7]); CssValue::Color(Color::new(r, g, b, a)) } _ => CssValue::Keyword(format!("#{hex}")), }}
fn hex_digit(c: char) -> u8 { match c { '0'..='9' => c as u8 - b'0', 'a'..='f' => c as u8 - b'a' + 10, 'A'..='F' => c as u8 - b'A' + 10, _ => 0, }}
fn hex_byte(hi: char, lo: char) -> u8 { hex_digit(hi) * 16 + hex_digit(lo)}
fn parse_function(name: &str, args: &[ComponentValue]) -> CssValue { match name.to_ascii_lowercase().as_str() { "rgb" => parse_rgb(args, false), "rgba" => parse_rgb(args, true), _ => CssValue::Keyword(format!("{name}()")), }}
fn parse_rgb(args: &[ComponentValue], _has_alpha: bool) -> CssValue { let nums: Vec<f64> = args .iter() .filter_map(|cv| match cv { ComponentValue::Number(n, _) => Some(*n), ComponentValue::Percentage(n) => Some(*n * 2.55), _ => Option::None, }) .collect();
match nums.len() { 3 => CssValue::Color(Color::rgb( clamp_u8(nums[0]), clamp_u8(nums[1]), clamp_u8(nums[2]), )), 4 => { let a = if args .iter() .any(|cv| matches!(cv, ComponentValue::Percentage(_))) { // If any arg is a percentage, treat alpha as 0-1 float clamp_u8(nums[3] / 2.55 * 255.0) } else { // Check if alpha looks like a 0-1 range if nums[3] <= 1.0 { clamp_u8(nums[3] * 255.0) } else { clamp_u8(nums[3]) } }; CssValue::Color(Color::new( clamp_u8(nums[0]), clamp_u8(nums[1]), clamp_u8(nums[2]), a, )) } _ => CssValue::Keyword("rgb()".to_string()), }}
fn clamp_u8(n: f64) -> u8 { n.round().clamp(0.0, 255.0) as u8}
// ---------------------------------------------------------------------------// Named colors (CSS Level 1 + transparent)// ---------------------------------------------------------------------------
fn named_color(name: &str) -> Option<Color> { Some(match name { "black" => Color::rgb(0, 0, 0), "silver" => Color::rgb(192, 192, 192), "gray" | "grey" => Color::rgb(128, 128, 128), "white" => Color::rgb(255, 255, 255), "maroon" => Color::rgb(128, 0, 0), "red" => Color::rgb(255, 0, 0), "purple" => Color::rgb(128, 0, 128), "fuchsia" | "magenta" => Color::rgb(255, 0, 255), "green" => Color::rgb(0, 128, 0), "lime" => Color::rgb(0, 255, 0), "olive" => Color::rgb(128, 128, 0), "yellow" => Color::rgb(255, 255, 0), "navy" => Color::rgb(0, 0, 128), "blue" => Color::rgb(0, 0, 255), "teal" => Color::rgb(0, 128, 128), "aqua" | "cyan" => Color::rgb(0, 255, 255), "orange" => Color::rgb(255, 165, 0), _ => return Option::None, })}
// ---------------------------------------------------------------------------// Shorthand expansion// ---------------------------------------------------------------------------
/// Expand a CSS declaration into longhand declarations./// Returns `None` if the property is not a known shorthand.pub fn expand_shorthand( property: &str, values: &[ComponentValue], important: bool,) -> Option<Vec<LonghandDeclaration>> { match property { "margin" => Some(expand_box_shorthand("margin", values, important)), "padding" => Some(expand_box_shorthand("padding", values, important)), "border" => Some(expand_border(values, important)), "border-width" => Some( expand_box_shorthand("border", values, important) .into_iter() .map(|mut d| { d.property = format!("{}-width", d.property); d }) .collect(), ), "border-style" => Some( expand_box_shorthand("border", values, important) .into_iter() .map(|mut d| { d.property = format!("{}-style", d.property); d }) .collect(), ), "border-color" => Some( expand_box_shorthand("border", values, important) .into_iter() .map(|mut d| { d.property = format!("{}-color", d.property); d }) .collect(), ), "background" => Some(expand_background(values, important)), "flex" => Some(expand_flex(values, important)), "flex-flow" => Some(expand_flex_flow(values, important)), "gap" => Some(expand_gap(values, important)), _ => Option::None, }}
/// Expand the `flex` shorthand into `flex-grow`, `flex-shrink`, `flex-basis`.fn expand_flex(values: &[ComponentValue], important: bool) -> Vec<LonghandDeclaration> { let parsed: Vec<CssValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace | ComponentValue::Comma)) .map(parse_single_value) .collect();
let (grow, shrink, basis) = match parsed.as_slice() { [CssValue::None] => (CssValue::Number(0.0), CssValue::Number(0.0), CssValue::Auto), [CssValue::Auto] => (CssValue::Number(1.0), CssValue::Number(1.0), CssValue::Auto), [CssValue::Number(g)] => (CssValue::Number(*g), CssValue::Number(1.0), CssValue::Zero), [CssValue::Zero] => (CssValue::Number(0.0), CssValue::Number(1.0), CssValue::Zero), [CssValue::Number(g), CssValue::Number(s)] => { (CssValue::Number(*g), CssValue::Number(*s), CssValue::Zero) } [CssValue::Number(g), CssValue::Number(s), basis] => { (CssValue::Number(*g), CssValue::Number(*s), basis.clone()) } _ => (CssValue::Number(0.0), CssValue::Number(1.0), CssValue::Auto), };
vec![ LonghandDeclaration { property: "flex-grow".to_string(), value: grow, important, }, LonghandDeclaration { property: "flex-shrink".to_string(), value: shrink, important, }, LonghandDeclaration { property: "flex-basis".to_string(), value: basis, important, }, ]}
/// Expand the `flex-flow` shorthand into `flex-direction` and `flex-wrap`.fn expand_flex_flow(values: &[ComponentValue], important: bool) -> Vec<LonghandDeclaration> { let parsed: Vec<CssValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace | ComponentValue::Comma)) .map(parse_single_value) .collect();
let mut direction = CssValue::Keyword("row".to_string()); let mut wrap = CssValue::Keyword("nowrap".to_string());
for val in &parsed { if let CssValue::Keyword(k) = val { match k.as_str() { "row" | "row-reverse" | "column" | "column-reverse" => { direction = val.clone(); } "nowrap" | "wrap" | "wrap-reverse" => { wrap = val.clone(); } _ => {} } } }
vec![ LonghandDeclaration { property: "flex-direction".to_string(), value: direction, important, }, LonghandDeclaration { property: "flex-wrap".to_string(), value: wrap, important, }, ]}
/// Expand the `gap` shorthand into `row-gap` and `column-gap`.fn expand_gap(values: &[ComponentValue], important: bool) -> Vec<LonghandDeclaration> { let parsed: Vec<CssValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace | ComponentValue::Comma)) .map(parse_single_value) .collect();
let (row, col) = match parsed.as_slice() { [single] => (single.clone(), single.clone()), [r, c] => (r.clone(), c.clone()), _ => (CssValue::Zero, CssValue::Zero), };
vec![ LonghandDeclaration { property: "row-gap".to_string(), value: row, important, }, LonghandDeclaration { property: "column-gap".to_string(), value: col, important, }, ]}
/// Expand a box-model shorthand (margin, padding) using the 1-to-4 value pattern.fn expand_box_shorthand( prefix: &str, values: &[ComponentValue], important: bool,) -> Vec<LonghandDeclaration> { let parsed: Vec<CssValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace | ComponentValue::Comma)) .map(parse_single_value) .collect();
let (top, right, bottom, left) = match parsed.len() { 1 => ( parsed[0].clone(), parsed[0].clone(), parsed[0].clone(), parsed[0].clone(), ), 2 => ( parsed[0].clone(), parsed[1].clone(), parsed[0].clone(), parsed[1].clone(), ), 3 => ( parsed[0].clone(), parsed[1].clone(), parsed[2].clone(), parsed[1].clone(), ), 4 => ( parsed[0].clone(), parsed[1].clone(), parsed[2].clone(), parsed[3].clone(), ), _ => { let fallback = if parsed.is_empty() { CssValue::Zero } else { parsed[0].clone() }; ( fallback.clone(), fallback.clone(), fallback.clone(), fallback, ) } };
vec![ LonghandDeclaration { property: format!("{prefix}-top"), value: top, important, }, LonghandDeclaration { property: format!("{prefix}-right"), value: right, important, }, LonghandDeclaration { property: format!("{prefix}-bottom"), value: bottom, important, }, LonghandDeclaration { property: format!("{prefix}-left"), value: left, important, }, ]}
/// Expand `border` shorthand into border-width, border-style, border-color.fn expand_border(values: &[ComponentValue], important: bool) -> Vec<LonghandDeclaration> { let parsed: Vec<CssValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace)) .map(parse_single_value) .collect();
let mut width = CssValue::Keyword("medium".to_string()); let mut style = CssValue::None; let mut color = CssValue::CurrentColor;
for val in &parsed { match val { CssValue::Length(_, _) | CssValue::Zero => width = val.clone(), CssValue::Color(_) | CssValue::CurrentColor | CssValue::Transparent => { color = val.clone() } CssValue::Keyword(kw) => match kw.as_str() { "thin" | "medium" | "thick" => width = val.clone(), "none" | "hidden" | "dotted" | "dashed" | "solid" | "double" | "groove" | "ridge" | "inset" | "outset" => style = val.clone(), _ => { // Could be a named color if let Some(c) = named_color(kw) { color = CssValue::Color(c); } } }, _ => {} } }
vec![ LonghandDeclaration { property: "border-width".to_string(), value: width, important, }, LonghandDeclaration { property: "border-style".to_string(), value: style, important, }, LonghandDeclaration { property: "border-color".to_string(), value: color, important, }, ]}
/// Expand `background` shorthand (basic: color only for now).fn expand_background(values: &[ComponentValue], important: bool) -> Vec<LonghandDeclaration> { let parsed: Vec<CssValue> = values .iter() .filter(|v| !matches!(v, ComponentValue::Whitespace)) .map(parse_single_value) .collect();
let mut bg_color = CssValue::Transparent;
for val in &parsed { match val { CssValue::Color(_) | CssValue::CurrentColor | CssValue::Transparent => { bg_color = val.clone() } CssValue::Keyword(kw) => { if let Some(c) = named_color(kw) { bg_color = CssValue::Color(c); } else { match kw.as_str() { "none" => {} // background-image: none _ => bg_color = val.clone(), } } } _ => {} } }
vec![LonghandDeclaration { property: "background-color".to_string(), value: bg_color, important, }]}
// ---------------------------------------------------------------------------// Tests// ---------------------------------------------------------------------------
#[cfg(test)]mod tests { use super::*; use crate::tokenizer::{HashType, NumericType};
// -- Length tests --------------------------------------------------------
#[test] fn test_parse_px() { let cv = ComponentValue::Dimension(16.0, NumericType::Integer, "px".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(16.0, LengthUnit::Px) ); }
#[test] fn test_parse_em() { let cv = ComponentValue::Dimension(1.5, NumericType::Number, "em".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(1.5, LengthUnit::Em) ); }
#[test] fn test_parse_rem() { let cv = ComponentValue::Dimension(2.0, NumericType::Number, "rem".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(2.0, LengthUnit::Rem) ); }
#[test] fn test_parse_pt() { let cv = ComponentValue::Dimension(12.0, NumericType::Integer, "pt".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(12.0, LengthUnit::Pt) ); }
#[test] fn test_parse_cm() { let cv = ComponentValue::Dimension(2.54, NumericType::Number, "cm".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(2.54, LengthUnit::Cm) ); }
#[test] fn test_parse_mm() { let cv = ComponentValue::Dimension(10.0, NumericType::Integer, "mm".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(10.0, LengthUnit::Mm) ); }
#[test] fn test_parse_in() { let cv = ComponentValue::Dimension(1.0, NumericType::Integer, "in".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(1.0, LengthUnit::In) ); }
#[test] fn test_parse_pc() { let cv = ComponentValue::Dimension(6.0, NumericType::Integer, "pc".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(6.0, LengthUnit::Pc) ); }
#[test] fn test_parse_vw() { let cv = ComponentValue::Dimension(50.0, NumericType::Integer, "vw".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(50.0, LengthUnit::Vw) ); }
#[test] fn test_parse_vh() { let cv = ComponentValue::Dimension(100.0, NumericType::Integer, "vh".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(100.0, LengthUnit::Vh) ); }
#[test] fn test_parse_vmin() { let cv = ComponentValue::Dimension(50.0, NumericType::Integer, "vmin".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(50.0, LengthUnit::Vmin) ); }
#[test] fn test_parse_vmax() { let cv = ComponentValue::Dimension(50.0, NumericType::Integer, "vmax".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(50.0, LengthUnit::Vmax) ); }
#[test] fn test_parse_percentage() { let cv = ComponentValue::Percentage(50.0); assert_eq!(parse_single_value(&cv), CssValue::Percentage(50.0)); }
#[test] fn test_parse_zero() { let cv = ComponentValue::Number(0.0, NumericType::Integer); assert_eq!(parse_single_value(&cv), CssValue::Zero); }
#[test] fn test_parse_number() { let cv = ComponentValue::Number(42.0, NumericType::Integer); assert_eq!(parse_single_value(&cv), CssValue::Number(42.0)); }
// -- Color tests --------------------------------------------------------
#[test] fn test_hex_color_3() { let cv = ComponentValue::Hash("f00".to_string(), HashType::Id); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(255, 0, 0)) ); }
#[test] fn test_hex_color_4() { let cv = ComponentValue::Hash("f00a".to_string(), HashType::Id); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::new(255, 0, 0, 170)) ); }
#[test] fn test_hex_color_6() { let cv = ComponentValue::Hash("ff8800".to_string(), HashType::Id); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(255, 136, 0)) ); }
#[test] fn test_hex_color_8() { let cv = ComponentValue::Hash("ff880080".to_string(), HashType::Id); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::new(255, 136, 0, 128)) ); }
#[test] fn test_named_color_red() { let cv = ComponentValue::Ident("red".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(255, 0, 0)) ); }
#[test] fn test_named_color_blue() { let cv = ComponentValue::Ident("blue".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(0, 0, 255)) ); }
#[test] fn test_named_color_black() { let cv = ComponentValue::Ident("black".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(0, 0, 0)) ); }
#[test] fn test_named_color_white() { let cv = ComponentValue::Ident("white".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(255, 255, 255)) ); }
#[test] fn test_transparent() { let cv = ComponentValue::Ident("transparent".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Transparent); }
#[test] fn test_current_color() { let cv = ComponentValue::Ident("currentColor".to_string()); assert_eq!(parse_single_value(&cv), CssValue::CurrentColor); }
#[test] fn test_rgb_function() { let args = vec![ ComponentValue::Number(255.0, NumericType::Integer), ComponentValue::Comma, ComponentValue::Whitespace, ComponentValue::Number(128.0, NumericType::Integer), ComponentValue::Comma, ComponentValue::Whitespace, ComponentValue::Number(0.0, NumericType::Integer), ]; let cv = ComponentValue::Function("rgb".to_string(), args); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(255, 128, 0)) ); }
#[test] fn test_rgba_function() { let args = vec![ ComponentValue::Number(255.0, NumericType::Integer), ComponentValue::Comma, ComponentValue::Whitespace, ComponentValue::Number(0.0, NumericType::Integer), ComponentValue::Comma, ComponentValue::Whitespace, ComponentValue::Number(0.0, NumericType::Integer), ComponentValue::Comma, ComponentValue::Whitespace, ComponentValue::Number(0.5, NumericType::Number), ]; let cv = ComponentValue::Function("rgba".to_string(), args); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::new(255, 0, 0, 128)) ); }
// -- Keyword tests ------------------------------------------------------
#[test] fn test_keyword_auto() { let cv = ComponentValue::Ident("auto".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Auto); }
#[test] fn test_keyword_inherit() { let cv = ComponentValue::Ident("inherit".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Inherit); }
#[test] fn test_keyword_initial() { let cv = ComponentValue::Ident("initial".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Initial); }
#[test] fn test_keyword_unset() { let cv = ComponentValue::Ident("unset".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Unset); }
#[test] fn test_keyword_none() { let cv = ComponentValue::Ident("none".to_string()); assert_eq!(parse_single_value(&cv), CssValue::None); }
#[test] fn test_keyword_display_block() { let cv = ComponentValue::Ident("block".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Keyword("block".to_string()) ); }
#[test] fn test_keyword_display_inline() { let cv = ComponentValue::Ident("inline".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Keyword("inline".to_string()) ); }
#[test] fn test_keyword_display_flex() { let cv = ComponentValue::Ident("flex".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Keyword("flex".to_string()) ); }
#[test] fn test_keyword_position() { for kw in &["static", "relative", "absolute", "fixed"] { let cv = ComponentValue::Ident(kw.to_string()); assert_eq!(parse_single_value(&cv), CssValue::Keyword(kw.to_string())); } }
#[test] fn test_keyword_text_align() { for kw in &["left", "center", "right", "justify"] { let cv = ComponentValue::Ident(kw.to_string()); assert_eq!(parse_single_value(&cv), CssValue::Keyword(kw.to_string())); } }
#[test] fn test_keyword_font_weight() { let cv = ComponentValue::Ident("bold".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Keyword("bold".to_string()) ); let cv = ComponentValue::Ident("normal".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Keyword("normal".to_string()) ); // Numeric font-weight let cv = ComponentValue::Number(700.0, NumericType::Integer); assert_eq!(parse_single_value(&cv), CssValue::Number(700.0)); }
#[test] fn test_keyword_overflow() { for kw in &["visible", "hidden", "scroll", "auto"] { let cv = ComponentValue::Ident(kw.to_string()); let expected = match *kw { "auto" => CssValue::Auto, _ => CssValue::Keyword(kw.to_string()), }; assert_eq!(parse_single_value(&cv), expected); } }
// -- parse_value (multi-value) ------------------------------------------
#[test] fn test_parse_value_single() { let values = vec![ComponentValue::Ident("red".to_string())]; assert_eq!(parse_value(&values), CssValue::Color(Color::rgb(255, 0, 0))); }
#[test] fn test_parse_value_multi() { let values = vec![ ComponentValue::Dimension(10.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(20.0, NumericType::Integer, "px".to_string()), ]; assert_eq!( parse_value(&values), CssValue::List(vec![ CssValue::Length(10.0, LengthUnit::Px), CssValue::Length(20.0, LengthUnit::Px), ]) ); }
// -- Shorthand expansion tests ------------------------------------------
#[test] fn test_margin_one_value() { let values = vec![ComponentValue::Dimension( 10.0, NumericType::Integer, "px".to_string(), )]; let result = expand_shorthand("margin", &values, false).unwrap(); assert_eq!(result.len(), 4); for decl in &result { assert_eq!(decl.value, CssValue::Length(10.0, LengthUnit::Px)); } assert_eq!(result[0].property, "margin-top"); assert_eq!(result[1].property, "margin-right"); assert_eq!(result[2].property, "margin-bottom"); assert_eq!(result[3].property, "margin-left"); }
#[test] fn test_margin_two_values() { let values = vec![ ComponentValue::Dimension(10.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(20.0, NumericType::Integer, "px".to_string()), ]; let result = expand_shorthand("margin", &values, false).unwrap(); assert_eq!(result[0].value, CssValue::Length(10.0, LengthUnit::Px)); // top assert_eq!(result[1].value, CssValue::Length(20.0, LengthUnit::Px)); // right assert_eq!(result[2].value, CssValue::Length(10.0, LengthUnit::Px)); // bottom assert_eq!(result[3].value, CssValue::Length(20.0, LengthUnit::Px)); // left }
#[test] fn test_margin_three_values() { let values = vec![ ComponentValue::Dimension(10.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(20.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(30.0, NumericType::Integer, "px".to_string()), ]; let result = expand_shorthand("margin", &values, false).unwrap(); assert_eq!(result[0].value, CssValue::Length(10.0, LengthUnit::Px)); // top assert_eq!(result[1].value, CssValue::Length(20.0, LengthUnit::Px)); // right assert_eq!(result[2].value, CssValue::Length(30.0, LengthUnit::Px)); // bottom assert_eq!(result[3].value, CssValue::Length(20.0, LengthUnit::Px)); // left }
#[test] fn test_margin_four_values() { let values = vec![ ComponentValue::Dimension(10.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(20.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(30.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(40.0, NumericType::Integer, "px".to_string()), ]; let result = expand_shorthand("margin", &values, false).unwrap(); assert_eq!(result[0].value, CssValue::Length(10.0, LengthUnit::Px)); // top assert_eq!(result[1].value, CssValue::Length(20.0, LengthUnit::Px)); // right assert_eq!(result[2].value, CssValue::Length(30.0, LengthUnit::Px)); // bottom assert_eq!(result[3].value, CssValue::Length(40.0, LengthUnit::Px)); // left }
#[test] fn test_margin_auto() { let values = vec![ ComponentValue::Number(0.0, NumericType::Integer), ComponentValue::Whitespace, ComponentValue::Ident("auto".to_string()), ]; let result = expand_shorthand("margin", &values, false).unwrap(); assert_eq!(result[0].value, CssValue::Zero); // top assert_eq!(result[1].value, CssValue::Auto); // right assert_eq!(result[2].value, CssValue::Zero); // bottom assert_eq!(result[3].value, CssValue::Auto); // left }
#[test] fn test_padding_shorthand() { let values = vec![ComponentValue::Dimension( 5.0, NumericType::Integer, "px".to_string(), )]; let result = expand_shorthand("padding", &values, false).unwrap(); assert_eq!(result.len(), 4); assert_eq!(result[0].property, "padding-top"); assert_eq!(result[1].property, "padding-right"); assert_eq!(result[2].property, "padding-bottom"); assert_eq!(result[3].property, "padding-left"); }
#[test] fn test_border_shorthand() { let values = vec![ ComponentValue::Dimension(1.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Ident("solid".to_string()), ComponentValue::Whitespace, ComponentValue::Ident("red".to_string()), ]; let result = expand_shorthand("border", &values, false).unwrap(); assert_eq!(result.len(), 3); assert_eq!(result[0].property, "border-width"); assert_eq!(result[0].value, CssValue::Length(1.0, LengthUnit::Px)); assert_eq!(result[1].property, "border-style"); assert_eq!(result[1].value, CssValue::Keyword("solid".to_string())); assert_eq!(result[2].property, "border-color"); assert_eq!(result[2].value, CssValue::Color(Color::rgb(255, 0, 0))); }
#[test] fn test_border_shorthand_defaults() { // Just a width let values = vec![ComponentValue::Dimension( 2.0, NumericType::Integer, "px".to_string(), )]; let result = expand_shorthand("border", &values, false).unwrap(); assert_eq!(result[0].value, CssValue::Length(2.0, LengthUnit::Px)); assert_eq!(result[1].value, CssValue::None); // default style assert_eq!(result[2].value, CssValue::CurrentColor); // default color }
#[test] fn test_background_shorthand_color() { let values = vec![ComponentValue::Hash("ff0000".to_string(), HashType::Id)]; let result = expand_shorthand("background", &values, false).unwrap(); assert_eq!(result.len(), 1); assert_eq!(result[0].property, "background-color"); assert_eq!(result[0].value, CssValue::Color(Color::rgb(255, 0, 0))); }
#[test] fn test_non_shorthand_returns_none() { let values = vec![ComponentValue::Ident("red".to_string())]; assert!(expand_shorthand("color", &values, false).is_none()); }
#[test] fn test_important_propagated() { let values = vec![ComponentValue::Dimension( 10.0, NumericType::Integer, "px".to_string(), )]; let result = expand_shorthand("margin", &values, true).unwrap(); for decl in &result { assert!(decl.important); } }
// -- Integration: parse from CSS text -----------------------------------
#[test] fn test_parse_from_css_text() { use crate::parser::Parser;
let ss = Parser::parse("p { color: red; margin: 10px 20px; }"); let rule = match &ss.rules[0] { crate::parser::Rule::Style(r) => r, _ => panic!("expected style rule"), };
// color: red let color_val = parse_value(&rule.declarations[0].value); assert_eq!(color_val, CssValue::Color(Color::rgb(255, 0, 0)));
// margin: 10px 20px (multi-value) let margin_val = parse_value(&rule.declarations[1].value); assert_eq!( margin_val, CssValue::List(vec![ CssValue::Length(10.0, LengthUnit::Px), CssValue::Length(20.0, LengthUnit::Px), ]) ); }
#[test] fn test_shorthand_from_css_text() { use crate::parser::Parser;
let ss = Parser::parse("div { margin: 10px 20px 30px 40px; }"); let rule = match &ss.rules[0] { crate::parser::Rule::Style(r) => r, _ => panic!("expected style rule"), };
let longhands = expand_shorthand( &rule.declarations[0].property, &rule.declarations[0].value, rule.declarations[0].important, ) .unwrap();
assert_eq!(longhands[0].property, "margin-top"); assert_eq!(longhands[0].value, CssValue::Length(10.0, LengthUnit::Px)); assert_eq!(longhands[1].property, "margin-right"); assert_eq!(longhands[1].value, CssValue::Length(20.0, LengthUnit::Px)); assert_eq!(longhands[2].property, "margin-bottom"); assert_eq!(longhands[2].value, CssValue::Length(30.0, LengthUnit::Px)); assert_eq!(longhands[3].property, "margin-left"); assert_eq!(longhands[3].value, CssValue::Length(40.0, LengthUnit::Px)); }
#[test] fn test_case_insensitive_units() { let cv = ComponentValue::Dimension(16.0, NumericType::Integer, "PX".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Length(16.0, LengthUnit::Px) ); }
#[test] fn test_case_insensitive_color_name() { let cv = ComponentValue::Ident("RED".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(255, 0, 0)) ); }
#[test] fn test_case_insensitive_keywords() { let cv = ComponentValue::Ident("AUTO".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Auto);
let cv = ComponentValue::Ident("INHERIT".to_string()); assert_eq!(parse_single_value(&cv), CssValue::Inherit); }
#[test] fn test_named_color_grey_alias() { let cv = ComponentValue::Ident("grey".to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(128, 128, 128)) ); }
#[test] fn test_named_color_all_16_plus() { let colors = vec![ ("black", 0, 0, 0), ("silver", 192, 192, 192), ("gray", 128, 128, 128), ("white", 255, 255, 255), ("maroon", 128, 0, 0), ("red", 255, 0, 0), ("purple", 128, 0, 128), ("fuchsia", 255, 0, 255), ("green", 0, 128, 0), ("lime", 0, 255, 0), ("olive", 128, 128, 0), ("yellow", 255, 255, 0), ("navy", 0, 0, 128), ("blue", 0, 0, 255), ("teal", 0, 128, 128), ("aqua", 0, 255, 255), ("orange", 255, 165, 0), ]; for (name, r, g, b) in colors { let cv = ComponentValue::Ident(name.to_string()); assert_eq!( parse_single_value(&cv), CssValue::Color(Color::rgb(r, g, b)), "failed for {name}" ); } }
#[test] fn test_border_width_shorthand() { let values = vec![ ComponentValue::Dimension(1.0, NumericType::Integer, "px".to_string()), ComponentValue::Whitespace, ComponentValue::Dimension(2.0, NumericType::Integer, "px".to_string()), ]; let result = expand_shorthand("border-width", &values, false).unwrap(); assert_eq!(result.len(), 4); assert_eq!(result[0].property, "border-top-width"); assert_eq!(result[1].property, "border-right-width"); }
#[test] fn test_border_style_shorthand() { let values = vec![ComponentValue::Ident("solid".to_string())]; let result = expand_shorthand("border-style", &values, false).unwrap(); assert_eq!(result.len(), 4); assert_eq!(result[0].property, "border-top-style"); }
#[test] fn test_border_color_shorthand() { let values = vec![ComponentValue::Ident("red".to_string())]; let result = expand_shorthand("border-color", &values, false).unwrap(); assert_eq!(result.len(), 4); assert_eq!(result[0].property, "border-top-color"); }
#[test] fn test_string_value() { let cv = ComponentValue::String("hello".to_string()); assert_eq!( parse_single_value(&cv), CssValue::String("hello".to_string()) ); }}