1use serde::{Deserialize, Serialize};
3pub trait Node<'a> {}
4
5#[derive(Deserialize, Serialize, Clone)]
6pub struct SelectorsGroup<'a> {
7 #[serde(borrow)]
8 pub selectors: Vec<Selector<'a>>,
9}
10
11impl<'a> Node<'a> for SelectorsGroup<'a> {}
12
13#[derive(Deserialize, Serialize, Clone)]
14pub struct Selector<'a> {
15 #[serde(borrow)]
16 pub base: SelectorSequence<'a>,
17 #[serde(borrow)]
18 pub modifiers: Vec<(Combinator, SelectorSequence<'a>)>,
19}
20
21impl<'a> Node<'a> for Selector<'a> {}
22
23#[derive(Deserialize, Serialize, Clone)]
24#[serde(tag = "type")]
25pub enum Combinator {
26 Plus,
27 Greater,
28 Tilde,
29 None,
30}
31
32#[derive(Deserialize, Serialize, Clone)]
33pub struct SelectorSequence<'a> {
34 #[serde(borrow)]
35 pub type_selector: Option<TypeSelector<'a>>,
36 #[serde(borrow)]
37 pub attribute_selectors: Vec<AttributeSelector<'a>>,
38}
39
40impl<'a> Node<'a> for SelectorSequence<'a> {}
41
42#[derive(Deserialize, Serialize, Clone)]
43#[serde(tag = "type")]
44pub enum AttributeSelector<'a> {
45 Hash(&'a str),
46 Class(&'a str),
47 Attribute(Attribute<'a>),
48 Psuedo(Psuedo<'a>),
49 Negation(Negation<'a>),
50}
51
52impl<'a> Node<'a> for AttributeSelector<'a> {}
53
54#[derive(Deserialize, Serialize, Clone)]
55#[serde(tag = "type")]
56pub enum Namespace<'a> {
57 All,
58 Ident(&'a str),
59}
60
61impl<'a> Node<'a> for Namespace<'a> {}
62
63#[derive(Deserialize, Serialize, Clone)]
64pub struct TypeSelector<'a> {
65 pub namespace: Option<Namespace<'a>>,
66 pub element_name: Option<&'a str>,
67}
68
69impl<'a> Node<'a> for TypeSelector<'a> {}
70
71#[derive(Deserialize, Serialize, Clone)]
72pub enum Matcher {
73 Prefix,
74 Suffix,
75 Substring,
76 Equal,
77 Includes,
78 Dash,
79}
80
81#[derive(Deserialize, Serialize, Clone)]
82pub struct Attribute<'a> {
83 pub namespace: Option<Namespace<'a>>,
84 pub name: &'a str,
85 pub matcher: Option<Matcher>,
86 pub value: Option<&'a str>,
87}
88
89impl<'a> Node<'a> for Attribute<'a> {}
90
91#[derive(Deserialize, Serialize, Clone)]
92pub struct Psuedo<'a> {
93 pub is_class_type: bool, pub name: &'a str,
95 pub arg: Option<Expression<'a>>, }
97
98impl<'a> Node<'a> for Psuedo<'a> {}
99
100#[derive(Deserialize, Serialize, Clone)]
101pub struct Expression<'a> {
102 #[serde(borrow)]
103 pub items: Vec<ExpressionItem<'a>>,
104}
105
106impl<'a> Node<'a> for Expression<'a> {}
107
108#[derive(Deserialize, Serialize, Clone)]
109pub enum ExpressionItem<'a> {
110 Plus,
111 Minus,
112 Dimension(&'a str, &'a str),
113 Number(&'a str),
114 Str(&'a str),
115 Ident(&'a str),
116}
117
118impl<'a> Node<'a> for ExpressionItem<'a> {}
119
120#[derive(Deserialize, Serialize, Clone)]
121#[serde(tag = "type")]
122pub enum Negation<'a> {
123 TypeSelector(TypeSelector<'a>),
124 Hash(&'a str),
125 Class(&'a str),
126 Attribute(Attribute<'a>),
127 Psuedo(Psuedo<'a>),
128}
129
130impl<'a> Node<'a> for Negation<'a> {}