css_ast 0.0.24

CSS Abstract Syntax Trees with visitable nodes and style value types.
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

use css_parse::{Cursor, Diagnostic, KindSet, Parse, Parser, Result as ParserResult, T};
use csskit_derives::{IntoCursor, Peek, SemanticEq, ToCursors, ToSpan};

use super::Tag;

/// <https://drafts.csswg.org/selectors/#type-nmsp>
#[derive(Peek, ToSpan, ToCursors, SemanticEq, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
#[cfg_attr(feature = "visitable", derive(csskit_derives::Visitable), visit(self))]
#[derive(csskit_derives::NodeWithMetadata)]
pub struct Namespace {
	pub prefix: Option<NamespacePrefix>,
	pub tag: NamespaceTag,
}

impl<'a> Parse<'a> for Namespace {
	fn parse<I>(p: &mut Parser<'a, I>) -> ParserResult<Self>
	where
		I: Iterator<Item = Cursor> + Clone,
	{
		if p.peek::<T![*|]>() {
			let prefix = p.parse::<NamespacePrefix>()?;
			let tag = p.parse::<NamespaceTag>()?;
			return Ok(Self { prefix: Some(prefix), tag });
		}
		if p.peek::<T![|]>() {
			let prefix = p.parse::<NamespacePrefix>()?;
			let tag = p.parse::<NamespaceTag>()?;
			return Ok(Self { prefix: Some(prefix), tag });
		}

		let ident = p.parse::<T![Ident]>()?;
		let skip = p.set_skip(KindSet::NONE);
		if p.peek::<T![|]>() && !p.peek::<T![|=]>() {
			let pipe = p.parse::<T![|]>();
			let tag = p.parse::<NamespaceTag>();
			p.set_skip(skip);
			let prefix = NamespacePrefix::Name(ident, pipe?);
			return Ok(Self { prefix: Some(prefix), tag: tag? });
		}
		let tag = p.parse::<NamespaceTag>()?;
		Ok(Self { prefix: None, tag })
	}
}

#[derive(Peek, ToSpan, ToCursors, SemanticEq, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
pub enum NamespacePrefix {
	None(T![|]),
	Name(T![Ident], T![|]),
	Wildcard(T![*], T![|]),
}

impl<'a> Parse<'a> for NamespacePrefix {
	fn parse<I>(p: &mut Parser<'a, I>) -> ParserResult<Self>
	where
		I: Iterator<Item = Cursor> + Clone,
	{
		if p.peek::<T![|]>() {
			let pipe = p.parse::<T![|]>()?;
			Ok(Self::None(pipe))
		} else if p.peek::<T![*]>() {
			let star = p.parse::<T![*]>()?;
			let skip = p.set_skip(KindSet::NONE);
			let pipe = p.parse::<T![|]>();
			p.set_skip(skip);
			let pipe = pipe?;
			Ok(Self::Wildcard(star, pipe))
		} else {
			let star = p.parse::<T![Ident]>()?;
			let skip = p.set_skip(KindSet::NONE);
			let pipe = p.parse::<T![|]>();
			p.set_skip(skip);
			let pipe = pipe?;
			Ok(Self::Name(star, pipe))
		}
	}
}

#[derive(Peek, ToCursors, IntoCursor, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
pub enum NamespaceTag {
	Wildcard(T![*]),
	Tag(Tag),
}

impl<'a> Parse<'a> for NamespaceTag {
	fn parse<I>(p: &mut Parser<'a, I>) -> ParserResult<Self>
	where
		I: Iterator<Item = Cursor> + Clone,
	{
		if p.peek::<Self>() {
			if p.peek::<T![*]>() { Ok(Self::Wildcard(p.parse::<T![*]>()?)) } else { Ok(Self::Tag(p.parse::<Tag>()?)) }
		} else {
			Err(Diagnostic::new(p.next(), Diagnostic::unexpected))?
		}
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::CssAtomSet;
	use css_parse::{assert_parse, assert_parse_error};

	#[test]
	fn size_test() {
		assert_eq!(std::mem::size_of::<Namespace>(), 48);
	}

	#[test]
	fn test_writes() {
		assert_parse!(CssAtomSet::ATOMS, Namespace, "*|a");
		assert_parse!(CssAtomSet::ATOMS, Namespace, "html|div");
		assert_parse!(CssAtomSet::ATOMS, Namespace, "|span");
	}

	#[test]
	fn test_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, Namespace, "* | a");
	}
}