use crate::ComponentValue;
#[derive(Debug, Clone)]
pub struct CssDeclaration {
pub name: String,
pub value: Vec<ComponentValue>,
pub important: bool,
pub original_text: Option<String>,
}
impl CssDeclaration {
pub fn new(name: impl Into<String>, value: Vec<ComponentValue>, important: bool) -> Self {
Self {
name: name.into(),
value,
important,
original_text: None,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct CssStyleDeclaration {
pub declarations: Vec<CssDeclaration>,
pub readonly: bool,
}
impl CssStyleDeclaration {
pub fn new() -> Self {
Self::default()
}
pub fn len(&self) -> usize {
self.declarations.len()
}
pub fn is_empty(&self) -> bool {
self.declarations.is_empty()
}
pub fn iter(&self) -> std::slice::Iter<'_, CssDeclaration> {
self.declarations.iter()
}
pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, CssDeclaration> {
self.declarations.iter_mut()
}
pub fn get_property(&self, name: &str) -> Option<&CssDeclaration> {
self.declarations.iter().rev().find(|d| d.name == name)
}
pub fn get_property_value(&self, name: &str) -> Option<&[ComponentValue]> {
self.get_property(name).map(|d| d.value.as_slice())
}
pub fn push(&mut self, decl: CssDeclaration) {
self.declarations.push(decl);
}
}
impl CssStyleDeclaration {
pub fn from_vec(declarations: Vec<CssDeclaration>) -> Self {
Self {
declarations,
readonly: false,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn declaration_new_basic() {
let d = CssDeclaration::new("color", Vec::new(), false);
assert_eq!(d.name, "color");
assert!(d.value.is_empty());
assert!(!d.important);
}
#[test]
fn declaration_new_with_important() {
let d = CssDeclaration::new("color", Vec::new(), true);
assert!(d.important);
}
#[test]
fn style_declaration_default_empty() {
let block = CssStyleDeclaration::default();
assert!(block.is_empty());
assert_eq!(block.len(), 0);
assert!(!block.readonly);
}
#[test]
fn style_declaration_push_and_len() {
let mut block = CssStyleDeclaration::new();
block.push(CssDeclaration::new("a", Vec::new(), false));
block.push(CssDeclaration::new("b", Vec::new(), false));
assert_eq!(block.len(), 2);
assert!(!block.is_empty());
}
#[test]
fn style_declaration_get_property_returns_last_match() {
let mut block = CssStyleDeclaration::new();
block.push(CssDeclaration::new("color", Vec::new(), false));
block.push(CssDeclaration::new("font-size", Vec::new(), false));
block.push(CssDeclaration::new("color", Vec::new(), true));
let got = block.get_property("color").unwrap();
assert!(got.important);
}
#[test]
fn style_declaration_get_property_missing_returns_none() {
let block = CssStyleDeclaration::new();
assert!(block.get_property("color").is_none());
assert!(block.get_property_value("color").is_none());
}
#[test]
fn style_declaration_iter() {
let mut block = CssStyleDeclaration::new();
block.push(CssDeclaration::new("a", Vec::new(), false));
block.push(CssDeclaration::new("b", Vec::new(), false));
let names: Vec<_> = block.iter().map(|d| d.name.as_str()).collect();
assert_eq!(names, vec!["a", "b"]);
}
#[test]
fn style_declaration_from_vec() {
let block = CssStyleDeclaration::from_vec(vec![
CssDeclaration::new("a", Vec::new(), false),
CssDeclaration::new("b", Vec::new(), false),
]);
assert_eq!(block.len(), 2);
assert!(!block.readonly);
}
#[test]
fn style_declaration_iter_mut_can_modify() {
let mut block = CssStyleDeclaration::new();
block.push(CssDeclaration::new("a", Vec::new(), false));
for d in block.iter_mut() {
d.important = true;
}
assert!(block.get_property("a").unwrap().important);
}
#[test]
fn style_declaration_clone_preserves_state() {
let mut block = CssStyleDeclaration::new();
block.push(CssDeclaration::new("a", Vec::new(), false));
block.readonly = true;
let cloned = block.clone();
assert_eq!(cloned.len(), 1);
assert!(cloned.readonly);
}
}