css3-selector 0.1.3

A CSS3 selector parser
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/// https://www.w3.org/TR/2018/REC-selectors-3-20181106/#grammar
use serde::{Deserialize, Serialize};
pub trait Node<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub struct SelectorsGroup<'a> {
    #[serde(borrow)]
    pub selectors: Vec<Selector<'a>>,
}

impl<'a> Node<'a> for SelectorsGroup<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub struct Selector<'a> {
    #[serde(borrow)]
    pub base: SelectorSequence<'a>,
    #[serde(borrow)]
    pub modifiers: Vec<(Combinator, SelectorSequence<'a>)>,
}

impl<'a> Node<'a> for Selector<'a> {}

#[derive(Deserialize, Serialize, Clone)]
#[serde(tag = "type")]
pub enum Combinator {
    Plus,
    Greater,
    Tilde,
    None,
}

#[derive(Deserialize, Serialize, Clone)]
pub struct SelectorSequence<'a> {
    #[serde(borrow)]
    pub type_selector: Option<TypeSelector<'a>>,
    #[serde(borrow)]
    pub attribute_selectors: Vec<AttributeSelector<'a>>,
}

impl<'a> Node<'a> for SelectorSequence<'a> {}

#[derive(Deserialize, Serialize, Clone)]
#[serde(tag = "type")]
pub enum AttributeSelector<'a> {
    Hash(&'a str),
    Class(&'a str),
    Attribute(Attribute<'a>),
    Psuedo(Psuedo<'a>),
    Negation(Negation<'a>),
}

impl<'a> Node<'a> for AttributeSelector<'a> {}

#[derive(Deserialize, Serialize, Clone)]
#[serde(tag = "type")]
pub enum Namespace<'a> {
    All,
    Ident(&'a str),
}

impl<'a> Node<'a> for Namespace<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub struct TypeSelector<'a> {
    pub namespace: Option<Namespace<'a>>,
    pub element_name: Option<&'a str>,
}

impl<'a> Node<'a> for TypeSelector<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub enum Matcher {
    Prefix,
    Suffix,
    Substring,
    Equal,
    Includes,
    Dash,
}

#[derive(Deserialize, Serialize, Clone)]
pub struct Attribute<'a> {
    pub namespace: Option<Namespace<'a>>,
    pub name: &'a str,
    pub matcher: Option<Matcher>,
    pub value: Option<&'a str>,
}

impl<'a> Node<'a> for Attribute<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub struct Psuedo<'a> {
    pub is_class_type: bool, // if true, only one colon was used
    pub name: &'a str,
    pub arg: Option<Expression<'a>>, // if Some, then was a function
}

impl<'a> Node<'a> for Psuedo<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub struct Expression<'a> {
    #[serde(borrow)]
    pub items: Vec<ExpressionItem<'a>>,
}

impl<'a> Node<'a> for Expression<'a> {}

#[derive(Deserialize, Serialize, Clone)]
pub enum ExpressionItem<'a> {
    Plus,
    Minus,
    Dimension(&'a str, &'a str),
    Number(&'a str),
    Str(&'a str),
    Ident(&'a str),
}

impl<'a> Node<'a> for ExpressionItem<'a> {}

#[derive(Deserialize, Serialize, Clone)]
#[serde(tag = "type")]
pub enum Negation<'a> {
    TypeSelector(TypeSelector<'a>),
    Hash(&'a str),
    Class(&'a str),
    Attribute(Attribute<'a>),
    Psuedo(Psuedo<'a>),
}

impl<'a> Node<'a> for Negation<'a> {}