use crate::CssStyleDeclaration;
use muskitty_css::parser::ComponentValue;
#[derive(Debug, Clone)]
pub enum CssRule {
Style(CssStyleRule),
Import(CssImportRule),
Media(CssMediaRule),
FontFace(CssFontFaceRule),
Page(CssPageRule),
Keyframes(CssKeyframesRule),
Keyframe(CssKeyframeRule),
Namespace(CssNamespaceRule),
CounterStyle(CssCounterStyleRule),
Supports(CssSupportsRule),
Container(CssContainerRule),
LayerBlock(CssLayerBlockRule),
LayerStatement(CssLayerStatementRule),
Property(CssPropertyRule),
Scope(CssScopeRule),
Other(OtherRule),
}
impl CssRule {
pub fn type_id(&self) -> u16 {
match self {
CssRule::Style(_) => 1,
CssRule::Import(_) => 3,
CssRule::Media(_) => 4,
CssRule::FontFace(_) => 5,
CssRule::Page(_) => 6,
CssRule::Keyframes(_) => 7,
CssRule::Keyframe(_) => 8,
CssRule::Namespace(_) => 10,
CssRule::CounterStyle(_) => 11,
CssRule::Supports(_) => 12,
CssRule::Container(_) => 15,
CssRule::LayerBlock(_) => 16,
CssRule::LayerStatement(_) => 17,
CssRule::Property(_) => 18,
CssRule::Scope(_) => 19,
CssRule::Other(_) => 0,
}
}
pub fn has_child_rules(&self) -> bool {
match self {
CssRule::Style(r) => !r.css_rules.is_empty(),
CssRule::Media(r) => !r.css_rules.is_empty(),
CssRule::Supports(r) => !r.css_rules.is_empty(),
CssRule::Container(r) => !r.css_rules.is_empty(),
CssRule::LayerBlock(r) => !r.css_rules.is_empty(),
CssRule::Scope(r) => !r.css_rules.is_empty(),
CssRule::Keyframes(r) => !r.keyframes.is_empty(),
CssRule::Other(r) => !r.child_rules.is_empty(),
CssRule::Import(_)
| CssRule::FontFace(_)
| CssRule::Page(_)
| CssRule::Keyframe(_)
| CssRule::Namespace(_)
| CssRule::CounterStyle(_)
| CssRule::LayerStatement(_)
| CssRule::Property(_) => false,
}
}
}
#[derive(Debug, Clone)]
pub struct CssStyleRule {
pub selectors: Vec<ComponentValue>,
pub style: CssStyleDeclaration,
pub css_rules: Vec<CssRule>,
}
impl CssStyleRule {
pub fn new(selectors: Vec<ComponentValue>) -> Self {
Self {
selectors,
style: CssStyleDeclaration::new(),
css_rules: Vec::new(),
}
}
}
#[derive(Debug, Clone)]
pub struct CssImportRule {
pub href: String,
pub media: Vec<ComponentValue>,
}
#[derive(Debug, Clone)]
pub struct CssMediaRule {
pub condition: Vec<ComponentValue>,
pub css_rules: Vec<CssRule>,
}
#[derive(Debug, Clone)]
pub struct CssNamespaceRule {
pub namespace_uri: String,
pub prefix: Option<String>,
}
#[derive(Debug, Clone)]
pub struct CssSupportsRule {
pub condition: Vec<ComponentValue>,
pub css_rules: Vec<CssRule>,
}
#[derive(Debug, Clone)]
pub struct CssLayerBlockRule {
pub name: Option<String>,
pub css_rules: Vec<CssRule>,
}
#[derive(Debug, Clone)]
pub struct CssLayerStatementRule {
pub names: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct CssContainerRule {
pub condition: Vec<ComponentValue>,
pub css_rules: Vec<CssRule>,
}
#[derive(Debug, Clone)]
pub struct CssFontFaceRule {
pub style: CssStyleDeclaration,
}
#[derive(Debug, Clone)]
pub struct CssPageRule {
pub selectors: Vec<ComponentValue>,
pub style: CssStyleDeclaration,
}
#[derive(Debug, Clone)]
pub struct CssKeyframesRule {
pub name: Option<String>,
pub keyframes: Vec<CssKeyframeRule>,
}
#[derive(Debug, Clone)]
pub struct CssKeyframeRule {
pub key_text: Vec<ComponentValue>,
pub style: CssStyleDeclaration,
}
#[derive(Debug, Clone)]
pub struct CssCounterStyleRule {
pub name: String,
pub style: CssStyleDeclaration,
}
#[derive(Debug, Clone)]
pub struct CssPropertyRule {
pub name: String,
pub style: CssStyleDeclaration,
}
#[derive(Debug, Clone)]
pub struct CssScopeRule {
pub prelude: Vec<ComponentValue>,
pub css_rules: Vec<CssRule>,
}
#[derive(Debug, Clone)]
pub struct OtherRule {
pub name: String,
pub prelude: Vec<ComponentValue>,
pub declarations: Option<Vec<crate::CssDeclaration>>,
pub child_rules: Vec<CssRule>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn style_rule_new_empty() {
let r = CssStyleRule::new(Vec::new());
assert!(r.selectors.is_empty());
assert!(r.style.is_empty());
assert!(r.css_rules.is_empty());
}
#[test]
fn type_id_for_each_variant() {
assert_eq!(CssRule::Style(CssStyleRule::new(Vec::new())).type_id(), 1);
assert_eq!(
CssRule::Import(CssImportRule {
href: String::new(),
media: Vec::new(),
})
.type_id(),
3
);
assert_eq!(
CssRule::Media(CssMediaRule {
condition: Vec::new(),
css_rules: Vec::new(),
})
.type_id(),
4
);
assert_eq!(
CssRule::Namespace(CssNamespaceRule {
namespace_uri: String::new(),
prefix: None,
})
.type_id(),
10
);
assert_eq!(
CssRule::Supports(CssSupportsRule {
condition: Vec::new(),
css_rules: Vec::new(),
})
.type_id(),
12
);
assert_eq!(
CssRule::Container(CssContainerRule {
condition: Vec::new(),
css_rules: Vec::new(),
})
.type_id(),
15
);
assert_eq!(
CssRule::LayerBlock(CssLayerBlockRule {
name: None,
css_rules: Vec::new(),
})
.type_id(),
16
);
assert_eq!(
CssRule::LayerStatement(CssLayerStatementRule { names: Vec::new() }).type_id(),
17
);
assert_eq!(
CssRule::FontFace(CssFontFaceRule {
style: CssStyleDeclaration::new(),
})
.type_id(),
5
);
assert_eq!(
CssRule::Page(CssPageRule {
selectors: Vec::new(),
style: CssStyleDeclaration::new(),
})
.type_id(),
6
);
assert_eq!(
CssRule::Keyframes(CssKeyframesRule {
name: None,
keyframes: Vec::new(),
})
.type_id(),
7
);
assert_eq!(
CssRule::Keyframe(CssKeyframeRule {
key_text: Vec::new(),
style: CssStyleDeclaration::new(),
})
.type_id(),
8
);
assert_eq!(
CssRule::CounterStyle(CssCounterStyleRule {
name: String::new(),
style: CssStyleDeclaration::new(),
})
.type_id(),
11
);
assert_eq!(
CssRule::Property(CssPropertyRule {
name: String::new(),
style: CssStyleDeclaration::new(),
})
.type_id(),
18
);
assert_eq!(
CssRule::Scope(CssScopeRule {
prelude: Vec::new(),
css_rules: Vec::new(),
})
.type_id(),
19
);
assert_eq!(
CssRule::Other(OtherRule {
name: String::new(),
prelude: Vec::new(),
declarations: None,
child_rules: Vec::new(),
})
.type_id(),
0
);
}
#[test]
fn has_child_rules_default_false() {
assert!(!CssRule::Style(CssStyleRule::new(Vec::new())).has_child_rules());
assert!(!CssRule::Import(CssImportRule {
href: String::new(),
media: Vec::new(),
})
.has_child_rules());
assert!(!CssRule::Namespace(CssNamespaceRule {
namespace_uri: String::new(),
prefix: None,
})
.has_child_rules());
assert!(
!CssRule::LayerStatement(CssLayerStatementRule { names: Vec::new() }).has_child_rules()
);
assert!(!CssRule::FontFace(CssFontFaceRule {
style: CssStyleDeclaration::new(),
})
.has_child_rules());
assert!(!CssRule::Page(CssPageRule {
selectors: Vec::new(),
style: CssStyleDeclaration::new(),
})
.has_child_rules());
assert!(!CssRule::Keyframe(CssKeyframeRule {
key_text: Vec::new(),
style: CssStyleDeclaration::new(),
})
.has_child_rules());
assert!(!CssRule::CounterStyle(CssCounterStyleRule {
name: String::new(),
style: CssStyleDeclaration::new(),
})
.has_child_rules());
assert!(!CssRule::Property(CssPropertyRule {
name: String::new(),
style: CssStyleDeclaration::new(),
})
.has_child_rules());
}
#[test]
fn has_child_rules_with_nested() {
let style_with_nested = CssRule::Style(CssStyleRule {
selectors: Vec::new(),
style: CssStyleDeclaration::new(),
css_rules: vec![CssRule::Style(CssStyleRule::new(Vec::new()))],
});
assert!(style_with_nested.has_child_rules());
let media_with_child = CssRule::Media(CssMediaRule {
condition: Vec::new(),
css_rules: vec![CssRule::Style(CssStyleRule::new(Vec::new()))],
});
assert!(media_with_child.has_child_rules());
let keyframes_with_child = CssRule::Keyframes(CssKeyframesRule {
name: None,
keyframes: vec![CssKeyframeRule {
key_text: Vec::new(),
style: CssStyleDeclaration::new(),
}],
});
assert!(keyframes_with_child.has_child_rules());
let scope_with_child = CssRule::Scope(CssScopeRule {
prelude: Vec::new(),
css_rules: vec![CssRule::Style(CssStyleRule::new(Vec::new()))],
});
assert!(scope_with_child.has_child_rules());
}
#[test]
fn import_rule_fields() {
let r = CssImportRule {
href: "style.css".to_string(),
media: Vec::new(),
};
assert_eq!(r.href, "style.css");
}
#[test]
fn namespace_rule_with_prefix() {
let r = CssNamespaceRule {
namespace_uri: "http://www.w3.org/2000/svg".to_string(),
prefix: Some("svg".to_string()),
};
assert_eq!(r.prefix.as_deref(), Some("svg"));
}
#[test]
fn namespace_rule_default_namespace() {
let r = CssNamespaceRule {
namespace_uri: "http://www.w3.org/2000/svg".to_string(),
prefix: None,
};
assert!(r.prefix.is_none());
}
#[test]
fn layer_block_anonymous() {
let r = CssLayerBlockRule {
name: None,
css_rules: Vec::new(),
};
assert!(r.name.is_none());
}
#[test]
fn layer_block_named() {
let r = CssLayerBlockRule {
name: Some("base".to_string()),
css_rules: Vec::new(),
};
assert_eq!(r.name.as_deref(), Some("base"));
}
#[test]
fn layer_statement_multiple_names() {
let r = CssLayerStatementRule {
names: vec![
"base".to_string(),
"theme".to_string(),
"utilities".to_string(),
],
};
assert_eq!(r.names.len(), 3);
assert_eq!(r.names[1], "theme");
}
#[test]
fn other_rule_statement_form() {
let r = OtherRule {
name: "font-face".to_string(),
prelude: Vec::new(),
declarations: None,
child_rules: Vec::new(),
};
assert_eq!(r.name, "font-face");
assert!(r.declarations.is_none());
}
#[test]
fn other_rule_block_form() {
let r = OtherRule {
name: "font-feature-values".to_string(),
prelude: Vec::new(),
declarations: Some(Vec::new()),
child_rules: Vec::new(),
};
assert!(r.declarations.is_some());
}
#[test]
fn clone_preserves_structure() {
let rule = CssRule::Media(CssMediaRule {
condition: Vec::new(),
css_rules: vec![CssRule::Style(CssStyleRule::new(Vec::new()))],
});
let cloned = rule.clone();
assert!(cloned.has_child_rules());
}
}