@dvaji/cheerox 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (62) hide show
  1. package/Cargo.lock +1 -4
  2. package/Cargo.toml +3 -2
  3. package/THIRD_PARTY_NOTICES.md +5 -3
  4. package/cheerox.darwin-arm64.node +0 -0
  5. package/cheerox.darwin-x64.node +0 -0
  6. package/cheerox.linux-arm64-gnu.node +0 -0
  7. package/cheerox.linux-arm64-musl.node +0 -0
  8. package/cheerox.linux-x64-gnu.node +0 -0
  9. package/cheerox.linux-x64-musl.node +0 -0
  10. package/cheerox.win32-arm64-msvc.node +0 -0
  11. package/cheerox.win32-x64-msvc.node +0 -0
  12. package/dist/{cheerio-compat-DSwBAJ1s.cjs → cheerio-compat-8HucV2qE.cjs} +9 -7
  13. package/dist/cheerio-compat-8HucV2qE.cjs.map +1 -0
  14. package/dist/{cheerio-compat-DRLPzBdX.d.mts → cheerio-compat-BM4_lqVU.d.mts} +3 -3
  15. package/dist/{cheerio-compat-DRsINTwV.d.ts → cheerio-compat-BnFvIIuE.d.cts} +3 -3
  16. package/dist/{cheerio-compat-DRsINTwV.d.cts → cheerio-compat-BnFvIIuE.d.ts} +3 -3
  17. package/dist/{cheerio-compat-BS--qPzw.mjs → cheerio-compat-Dwarm-h8.mjs} +9 -7
  18. package/dist/cheerio-compat-Dwarm-h8.mjs.map +1 -0
  19. package/dist/cheerio-compat.cjs +1 -1
  20. package/dist/cheerio-compat.d.cts +1 -1
  21. package/dist/cheerio-compat.d.mts +1 -1
  22. package/dist/cheerio-compat.d.ts +1 -1
  23. package/dist/cheerio-compat.mjs +1 -1
  24. package/dist/index.d.mts +1 -1
  25. package/dist/{modern-CvXcTn82.mjs → modern-BwcwZX6l.mjs} +2 -2
  26. package/dist/{modern-CvXcTn82.mjs.map → modern-BwcwZX6l.mjs.map} +1 -1
  27. package/dist/{modern-CHQGP0Yt.cjs → modern-DMcsyA4b.cjs} +2 -2
  28. package/dist/{modern-CHQGP0Yt.cjs.map → modern-DMcsyA4b.cjs.map} +1 -1
  29. package/dist/modern.cjs +2 -2
  30. package/dist/modern.mjs +2 -2
  31. package/dist/{nodes-jbWWhssj.cjs → nodes-Be5sB8rQ.cjs} +23 -15
  32. package/dist/nodes-Be5sB8rQ.cjs.map +1 -0
  33. package/dist/{nodes-sYxb5qyZ.mjs → nodes-C95i5k2P.mjs} +23 -15
  34. package/dist/nodes-C95i5k2P.mjs.map +1 -0
  35. package/dist/slim.cjs +1 -1
  36. package/dist/slim.mjs +1 -1
  37. package/native/src/lib.rs +509 -1
  38. package/native/vendor/README.md +12 -3
  39. package/native/vendor/scraper-0.24.0/Cargo.toml +52 -0
  40. package/native/vendor/scraper-0.24.0/LICENSE +15 -0
  41. package/native/vendor/scraper-0.24.0/src/element_ref/element.rs +212 -0
  42. package/native/vendor/scraper-0.24.0/src/element_ref/mod.rs +236 -0
  43. package/native/vendor/scraper-0.24.0/src/element_ref/serializable.rs +15 -0
  44. package/native/vendor/scraper-0.24.0/src/error/utils.rs +91 -0
  45. package/native/vendor/scraper-0.24.0/src/error.rs +118 -0
  46. package/native/vendor/scraper-0.24.0/src/html/mod.rs +270 -0
  47. package/native/vendor/scraper-0.24.0/src/html/serializable.rs +27 -0
  48. package/native/vendor/scraper-0.24.0/src/html/tree_sink.rs +285 -0
  49. package/native/vendor/scraper-0.24.0/src/lib.rs +180 -0
  50. package/native/vendor/scraper-0.24.0/src/node/serializable.rs +52 -0
  51. package/native/vendor/scraper-0.24.0/src/node.rs +465 -0
  52. package/native/vendor/scraper-0.24.0/src/selectable.rs +70 -0
  53. package/native/vendor/scraper-0.24.0/src/selector.rs +290 -0
  54. package/package.json +1 -1
  55. package/scripts/check-release.mjs +2 -2
  56. package/scripts/generate-notices.mjs +10 -4
  57. package/src/cheerio-compat.ts +14 -4
  58. package/src/native.ts +23 -9
  59. package/dist/cheerio-compat-BS--qPzw.mjs.map +0 -1
  60. package/dist/cheerio-compat-DSwBAJ1s.cjs.map +0 -1
  61. package/dist/nodes-jbWWhssj.cjs.map +0 -1
  62. package/dist/nodes-sYxb5qyZ.mjs.map +0 -1
@@ -0,0 +1,212 @@
1
+ use html5ever::Namespace;
2
+ use selectors::{
3
+ attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint},
4
+ bloom::BloomFilter,
5
+ matching, Element, OpaqueElement,
6
+ };
7
+
8
+ use super::ElementRef;
9
+ use crate::selector::{CssLocalName, CssString, NonTSPseudoClass, PseudoElement, Simple};
10
+
11
+ /// Note: will never match against non-tree-structure pseudo-classes.
12
+ impl Element for ElementRef<'_> {
13
+ type Impl = Simple;
14
+
15
+ fn opaque(&self) -> OpaqueElement {
16
+ OpaqueElement::new(self.node.value())
17
+ }
18
+
19
+ fn parent_element(&self) -> Option<Self> {
20
+ self.parent().and_then(ElementRef::wrap)
21
+ }
22
+
23
+ fn parent_node_is_shadow_root(&self) -> bool {
24
+ false
25
+ }
26
+
27
+ fn containing_shadow_host(&self) -> Option<Self> {
28
+ None
29
+ }
30
+
31
+ fn is_pseudo_element(&self) -> bool {
32
+ false
33
+ }
34
+
35
+ fn is_part(&self, _name: &CssLocalName) -> bool {
36
+ false
37
+ }
38
+
39
+ fn is_same_type(&self, other: &Self) -> bool {
40
+ self.value().name == other.value().name
41
+ }
42
+
43
+ fn imported_part(&self, _: &CssLocalName) -> Option<CssLocalName> {
44
+ None
45
+ }
46
+
47
+ fn prev_sibling_element(&self) -> Option<Self> {
48
+ self.prev_siblings()
49
+ .find(|sibling| sibling.value().is_element())
50
+ .map(ElementRef::new)
51
+ }
52
+
53
+ fn next_sibling_element(&self) -> Option<Self> {
54
+ self.next_siblings()
55
+ .find(|sibling| sibling.value().is_element())
56
+ .map(ElementRef::new)
57
+ }
58
+
59
+ fn first_element_child(&self) -> Option<Self> {
60
+ self.children()
61
+ .find(|child| child.value().is_element())
62
+ .map(ElementRef::new)
63
+ }
64
+
65
+ fn is_html_element_in_html_document(&self) -> bool {
66
+ // FIXME: Is there more to this?
67
+ self.value().name.ns == ns!(html)
68
+ }
69
+
70
+ fn has_local_name(&self, name: &CssLocalName) -> bool {
71
+ self.value().name.local == name.0
72
+ }
73
+
74
+ fn has_namespace(&self, namespace: &Namespace) -> bool {
75
+ &self.value().name.ns == namespace
76
+ }
77
+
78
+ fn attr_matches(
79
+ &self,
80
+ ns: &NamespaceConstraint<&Namespace>,
81
+ local_name: &CssLocalName,
82
+ operation: &AttrSelectorOperation<&CssString>,
83
+ ) -> bool {
84
+ self.value().attrs.iter().any(|(key, value)| {
85
+ !matches!(*ns, NamespaceConstraint::Specific(url) if *url != key.ns)
86
+ && local_name.0 == key.local
87
+ && operation.eval_str(value)
88
+ })
89
+ }
90
+
91
+ fn match_non_ts_pseudo_class(
92
+ &self,
93
+ _pc: &NonTSPseudoClass,
94
+ _context: &mut matching::MatchingContext<'_, Self::Impl>,
95
+ ) -> bool {
96
+ false
97
+ }
98
+
99
+ fn match_pseudo_element(
100
+ &self,
101
+ _pe: &PseudoElement,
102
+ _context: &mut matching::MatchingContext<Self::Impl>,
103
+ ) -> bool {
104
+ false
105
+ }
106
+
107
+ fn is_link(&self) -> bool {
108
+ self.value().name() == "link"
109
+ }
110
+
111
+ fn is_html_slot_element(&self) -> bool {
112
+ true
113
+ }
114
+
115
+ fn has_id(&self, id: &CssLocalName, case_sensitivity: CaseSensitivity) -> bool {
116
+ match self.value().id() {
117
+ Some(val) => case_sensitivity.eq(id.0.as_bytes(), val.as_bytes()),
118
+ None => false,
119
+ }
120
+ }
121
+
122
+ fn has_class(&self, name: &CssLocalName, case_sensitivity: CaseSensitivity) -> bool {
123
+ self.value().has_class(&name.0, case_sensitivity)
124
+ }
125
+
126
+ fn has_custom_state(&self, _name: &CssLocalName) -> bool {
127
+ false
128
+ }
129
+
130
+ fn is_empty(&self) -> bool {
131
+ !self
132
+ .children()
133
+ .any(|child| child.value().is_element() || child.value().is_text())
134
+ }
135
+
136
+ fn is_root(&self) -> bool {
137
+ self.parent()
138
+ .is_some_and(|parent| parent.value().is_document())
139
+ }
140
+
141
+ fn apply_selector_flags(&self, _flags: matching::ElementSelectorFlags) {}
142
+
143
+ fn add_element_unique_hashes(&self, _filter: &mut BloomFilter) -> bool {
144
+ // FIXME: Do we want to add `self.node.id()` here?
145
+ false
146
+ }
147
+ }
148
+
149
+ #[cfg(test)]
150
+ mod tests {
151
+ use crate::html::Html;
152
+ use crate::selector::{CssLocalName, Selector};
153
+ use selectors::attr::CaseSensitivity;
154
+ use selectors::Element;
155
+
156
+ #[test]
157
+ fn test_has_id() {
158
+ let html = "<p id='link_id_456'>hey there</p>";
159
+ let fragment = Html::parse_fragment(html);
160
+ let sel = Selector::parse("p").unwrap();
161
+
162
+ let element = fragment.select(&sel).next().unwrap();
163
+ assert!(element.has_id(
164
+ &CssLocalName::from("link_id_456"),
165
+ CaseSensitivity::CaseSensitive
166
+ ));
167
+
168
+ let html = "<p>hey there</p>";
169
+ let fragment = Html::parse_fragment(html);
170
+ let element = fragment.select(&sel).next().unwrap();
171
+ assert!(!element.has_id(
172
+ &CssLocalName::from("any_link_id"),
173
+ CaseSensitivity::CaseSensitive
174
+ ));
175
+ }
176
+
177
+ #[test]
178
+ fn test_is_link() {
179
+ let html = "<link href='https://www.example.com'>";
180
+ let fragment = Html::parse_fragment(html);
181
+ let sel = Selector::parse("link").unwrap();
182
+ let element = fragment.select(&sel).next().unwrap();
183
+ assert!(element.is_link());
184
+
185
+ let html = "<p>hey there</p>";
186
+ let fragment = Html::parse_fragment(html);
187
+ let sel = Selector::parse("p").unwrap();
188
+ let element = fragment.select(&sel).next().unwrap();
189
+ assert!(!element.is_link());
190
+ }
191
+
192
+ #[test]
193
+ fn test_has_class() {
194
+ let html = "<p class='my_class'>hey there</p>";
195
+ let fragment = Html::parse_fragment(html);
196
+ let sel = Selector::parse("p").unwrap();
197
+ let element = fragment.select(&sel).next().unwrap();
198
+ assert!(element.has_class(
199
+ &CssLocalName::from("my_class"),
200
+ CaseSensitivity::CaseSensitive
201
+ ));
202
+
203
+ let html = "<p>hey there</p>";
204
+ let fragment = Html::parse_fragment(html);
205
+ let sel = Selector::parse("p").unwrap();
206
+ let element = fragment.select(&sel).next().unwrap();
207
+ assert!(!element.has_class(
208
+ &CssLocalName::from("my_class"),
209
+ CaseSensitivity::CaseSensitive
210
+ ));
211
+ }
212
+ }
@@ -0,0 +1,236 @@
1
+ //! Element references.
2
+
3
+ use std::fmt::{self, Debug};
4
+ use std::iter::FusedIterator;
5
+ use std::ops::Deref;
6
+
7
+ use ego_tree::iter::{Edge, Traverse};
8
+ use ego_tree::NodeRef;
9
+ use html5ever::serialize::{serialize, SerializeOpts, TraversalScope};
10
+ use selectors::matching::SelectorCaches;
11
+
12
+ use crate::node::Element;
13
+ use crate::{Node, Selector};
14
+
15
+ /// Wrapper around a reference to an element node.
16
+ ///
17
+ /// This wrapper implements the `Element` trait from the `selectors` crate, which allows it to be
18
+ /// matched against CSS selectors.
19
+ #[derive(Clone, Copy, PartialEq, Eq)]
20
+ pub struct ElementRef<'a> {
21
+ node: NodeRef<'a, Node>,
22
+ }
23
+
24
+ impl<'a> ElementRef<'a> {
25
+ fn new(node: NodeRef<'a, Node>) -> Self {
26
+ ElementRef { node }
27
+ }
28
+
29
+ /// Wraps a `NodeRef` only if it references a `Node::Element`.
30
+ pub fn wrap(node: NodeRef<'a, Node>) -> Option<Self> {
31
+ if node.value().is_element() {
32
+ Some(ElementRef::new(node))
33
+ } else {
34
+ None
35
+ }
36
+ }
37
+
38
+ /// Returns the `Element` referenced by `self`.
39
+ pub fn value(&self) -> &'a Element {
40
+ self.node.value().as_element().unwrap()
41
+ }
42
+
43
+ /// Returns an iterator over descendent elements matching a selector.
44
+ pub fn select<'b>(&self, selector: &'b Selector) -> Select<'a, 'b> {
45
+ let mut inner = self.traverse();
46
+ inner.next(); // Skip Edge::Open(self).
47
+
48
+ Select {
49
+ scope: *self,
50
+ inner,
51
+ selector,
52
+ caches: Default::default(),
53
+ }
54
+ }
55
+
56
+ fn serialize(&self, traversal_scope: TraversalScope) -> String {
57
+ let opts = SerializeOpts {
58
+ scripting_enabled: false, // It's not clear what this does.
59
+ traversal_scope,
60
+ create_missing_parent: false,
61
+ };
62
+ let mut buf = Vec::new();
63
+ serialize(&mut buf, self, opts).unwrap();
64
+ String::from_utf8(buf).unwrap()
65
+ }
66
+
67
+ /// Returns the HTML of this element.
68
+ pub fn html(&self) -> String {
69
+ self.serialize(TraversalScope::IncludeNode)
70
+ }
71
+
72
+ /// Returns the inner HTML of this element.
73
+ pub fn inner_html(&self) -> String {
74
+ self.serialize(TraversalScope::ChildrenOnly(None))
75
+ }
76
+
77
+ /// Returns the value of an attribute.
78
+ pub fn attr(&self, attr: &str) -> Option<&'a str> {
79
+ self.value().attr(attr)
80
+ }
81
+
82
+ /// Returns an iterator over descendent text nodes.
83
+ pub fn text(&self) -> Text<'a> {
84
+ Text {
85
+ inner: self.traverse(),
86
+ }
87
+ }
88
+
89
+ /// Iterate over all child nodes which are elements
90
+ ///
91
+ /// # Example
92
+ ///
93
+ /// ```
94
+ /// # use scraper::Html;
95
+ /// let fragment = Html::parse_fragment("foo<span>bar</span><a>baz</a>qux");
96
+ ///
97
+ /// let children = fragment.root_element().child_elements().map(|element| element.value().name()).collect::<Vec<_>>();
98
+ /// assert_eq!(children, ["span", "a"]);
99
+ /// ```
100
+ pub fn child_elements(&self) -> impl Iterator<Item = ElementRef<'a>> {
101
+ self.children().filter_map(ElementRef::wrap)
102
+ }
103
+
104
+ /// Iterate over all descendent nodes which are elements
105
+ ///
106
+ /// # Example
107
+ ///
108
+ /// ```
109
+ /// # use scraper::Html;
110
+ /// let fragment = Html::parse_fragment("foo<span><b>bar</b></span><a><i>baz</i></a>qux");
111
+ ///
112
+ /// let descendants = fragment.root_element().descendent_elements().map(|element| element.value().name()).collect::<Vec<_>>();
113
+ /// assert_eq!(descendants, ["html", "span", "b", "a", "i"]);
114
+ /// ```
115
+ pub fn descendent_elements(&self) -> impl Iterator<Item = ElementRef<'a>> {
116
+ self.descendants().filter_map(ElementRef::wrap)
117
+ }
118
+ }
119
+
120
+ impl Debug for ElementRef<'_> {
121
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
122
+ Debug::fmt(self.value(), f)
123
+ }
124
+ }
125
+
126
+ impl<'a> Deref for ElementRef<'a> {
127
+ type Target = NodeRef<'a, Node>;
128
+ fn deref(&self) -> &NodeRef<'a, Node> {
129
+ &self.node
130
+ }
131
+ }
132
+
133
+ /// Iterator over descendent elements matching a selector.
134
+ pub struct Select<'a, 'b> {
135
+ scope: ElementRef<'a>,
136
+ inner: Traverse<'a, Node>,
137
+ selector: &'b Selector,
138
+ caches: SelectorCaches,
139
+ }
140
+
141
+ impl Debug for Select<'_, '_> {
142
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
143
+ fmt.debug_struct("Select")
144
+ .field("scope", &self.scope)
145
+ .field("inner", &self.inner)
146
+ .field("selector", &self.selector)
147
+ .field("caches", &"..")
148
+ .finish()
149
+ }
150
+ }
151
+
152
+ impl Clone for Select<'_, '_> {
153
+ fn clone(&self) -> Self {
154
+ Self {
155
+ scope: self.scope,
156
+ inner: self.inner.clone(),
157
+ selector: self.selector,
158
+ caches: Default::default(),
159
+ }
160
+ }
161
+ }
162
+
163
+ impl<'a> Iterator for Select<'a, '_> {
164
+ type Item = ElementRef<'a>;
165
+
166
+ fn next(&mut self) -> Option<ElementRef<'a>> {
167
+ for edge in &mut self.inner {
168
+ if let Edge::Open(node) = edge {
169
+ if let Some(element) = ElementRef::wrap(node) {
170
+ if self.selector.matches_with_scope_and_cache(
171
+ &element,
172
+ Some(self.scope),
173
+ &mut self.caches,
174
+ ) {
175
+ return Some(element);
176
+ }
177
+ }
178
+ }
179
+ }
180
+ None
181
+ }
182
+ }
183
+
184
+ impl FusedIterator for Select<'_, '_> {}
185
+
186
+ /// Iterator over descendent text nodes.
187
+ #[derive(Debug, Clone)]
188
+ pub struct Text<'a> {
189
+ inner: Traverse<'a, Node>,
190
+ }
191
+
192
+ impl<'a> Iterator for Text<'a> {
193
+ type Item = &'a str;
194
+
195
+ fn next(&mut self) -> Option<&'a str> {
196
+ for edge in &mut self.inner {
197
+ if let Edge::Open(node) = edge {
198
+ if let Node::Text(ref text) = node.value() {
199
+ return Some(&**text);
200
+ }
201
+ }
202
+ }
203
+ None
204
+ }
205
+ }
206
+
207
+ impl FusedIterator for Text<'_> {}
208
+
209
+ mod element;
210
+ mod serializable;
211
+
212
+ #[cfg(test)]
213
+ mod tests {
214
+ use crate::html::Html;
215
+ use crate::selector::Selector;
216
+
217
+ #[test]
218
+ fn test_scope() {
219
+ let html = r"
220
+ <div>
221
+ <b>1</b>
222
+ <span>
223
+ <span><b>2</b></span>
224
+ <b>3</b>
225
+ </span>
226
+ </div>
227
+ ";
228
+ let fragment = Html::parse_fragment(html);
229
+ let sel1 = Selector::parse("div > span").unwrap();
230
+ let sel2 = Selector::parse(":scope > b").unwrap();
231
+
232
+ let element1 = fragment.select(&sel1).next().unwrap();
233
+ let element2 = element1.select(&sel2).next().unwrap();
234
+ assert_eq!(element2.inner_html(), "3");
235
+ }
236
+ }
@@ -0,0 +1,15 @@
1
+ use std::io::Error;
2
+
3
+ use html5ever::serialize::{Serialize, Serializer, TraversalScope};
4
+
5
+ use crate::ElementRef;
6
+
7
+ impl Serialize for ElementRef<'_> {
8
+ fn serialize<S: Serializer>(
9
+ &self,
10
+ serializer: &mut S,
11
+ traversal_scope: TraversalScope,
12
+ ) -> Result<(), Error> {
13
+ crate::node::serializable::serialize(**self, serializer, traversal_scope)
14
+ }
15
+ }
@@ -0,0 +1,91 @@
1
+ use cssparser::Token;
2
+
3
+ pub(crate) fn render_token(token: &Token<'_>) -> String {
4
+ match token {
5
+ Token::Ident(ident) => ident.to_string(),
6
+ Token::AtKeyword(value) => format!("@{value}"),
7
+ Token::Hash(name) | Token::IDHash(name) => format!("#{name}"),
8
+ Token::QuotedString(value) => format!("\"{value}\""),
9
+ Token::UnquotedUrl(value) => value.to_string(),
10
+ Token::Number {
11
+ has_sign: signed,
12
+ value: num,
13
+ int_value: _,
14
+ }
15
+ | Token::Percentage {
16
+ has_sign: signed,
17
+ unit_value: num,
18
+ int_value: _,
19
+ } => render_number(*signed, *num, token),
20
+ Token::Dimension {
21
+ has_sign: signed,
22
+ value: num,
23
+ int_value: _,
24
+ unit,
25
+ } => format!("{}{}", render_int(*signed, *num), unit),
26
+ Token::WhiteSpace(_) => String::from(" "),
27
+ Token::Comment(comment) => format!("/* {comment} */"),
28
+ Token::Function(name) => format!("{name}()"),
29
+ Token::BadString(string) => format!("<Bad String {string:?}>"),
30
+ Token::BadUrl(url) => format!("<Bad URL {url:?}>"),
31
+ // Single-character token
32
+ Token::Colon => ":".into(),
33
+ Token::Semicolon => ";".into(),
34
+ Token::Comma => ",".into(),
35
+ Token::IncludeMatch => "~=".into(),
36
+ Token::DashMatch => "|=".into(),
37
+ Token::PrefixMatch => "^=".into(),
38
+ Token::SuffixMatch => "$=".into(),
39
+ Token::SubstringMatch => "*=".into(),
40
+ Token::CDO => "<!--".into(),
41
+ Token::CDC => "-->".into(),
42
+ Token::ParenthesisBlock => "<(".into(),
43
+ Token::SquareBracketBlock => "<[".into(),
44
+ Token::CurlyBracketBlock => "<{".into(),
45
+ Token::CloseParenthesis => "<)".into(),
46
+ Token::CloseSquareBracket => "<]".into(),
47
+ Token::CloseCurlyBracket => "<}".into(),
48
+ Token::Delim(delim) => (*delim).into(),
49
+ }
50
+ }
51
+
52
+ fn render_number(signed: bool, num: f32, token: &Token) -> String {
53
+ let num = render_int(signed, num);
54
+
55
+ match token {
56
+ Token::Number { .. } => num,
57
+ Token::Percentage { .. } => format!("{num}%"),
58
+ _ => panic!("render_number is not supposed to be called on a non-numerical token"),
59
+ }
60
+ }
61
+
62
+ fn render_int(signed: bool, num: f32) -> String {
63
+ if signed {
64
+ render_int_signed(num)
65
+ } else {
66
+ render_int_unsigned(num)
67
+ }
68
+ }
69
+
70
+ fn render_int_signed(num: f32) -> String {
71
+ if num > 0.0 {
72
+ format!("+{num}")
73
+ } else {
74
+ format!("-{num}")
75
+ }
76
+ }
77
+
78
+ fn render_int_unsigned(num: f32) -> String {
79
+ format!("{num}")
80
+ }
81
+
82
+ #[cfg(test)]
83
+ mod tests {
84
+ use crate::Selector;
85
+
86
+ #[test]
87
+ fn regression_test_issue212() {
88
+ let err = Selector::parse("div138293@!#@!!@#").unwrap_err();
89
+ assert_eq!(err.to_string(), "Token \"@\" was not expected");
90
+ }
91
+ }
@@ -0,0 +1,118 @@
1
+ //! Custom error types for diagnostics
2
+ //! Includes re-exported error types from dependencies
3
+
4
+ mod utils;
5
+
6
+ use std::{error::Error, fmt::Display};
7
+
8
+ use cssparser::{BasicParseErrorKind, ParseErrorKind, Token};
9
+ use selectors::parser::SelectorParseErrorKind;
10
+
11
+ /// Error type that is returned when calling `Selector::parse`
12
+ #[derive(Debug, Clone)]
13
+ pub enum SelectorErrorKind<'a> {
14
+ /// A `Token` was not expected
15
+ UnexpectedToken(Token<'a>),
16
+
17
+ /// End-Of-Line was unexpected
18
+ EndOfLine,
19
+
20
+ /// `@` rule is invalid
21
+ InvalidAtRule(String),
22
+
23
+ /// The body of an `@` rule is invalid
24
+ InvalidAtRuleBody,
25
+
26
+ /// The qualified rule is invalid
27
+ QualRuleInvalid,
28
+
29
+ /// Expected a `::` for a pseudoelement
30
+ ExpectedColonOnPseudoElement(Token<'a>),
31
+
32
+ /// Expected an identity for a pseudoelement
33
+ ExpectedIdentityOnPseudoElement(Token<'a>),
34
+
35
+ /// A `SelectorParseErrorKind` error that isn't really supposed to happen did
36
+ UnexpectedSelectorParseError(SelectorParseErrorKind<'a>),
37
+ }
38
+
39
+ impl<'a> From<cssparser::ParseError<'a, SelectorParseErrorKind<'a>>> for SelectorErrorKind<'a> {
40
+ fn from(original: cssparser::ParseError<'a, SelectorParseErrorKind<'a>>) -> Self {
41
+ // NOTE: This could be improved, but I dont
42
+ // exactly know how
43
+ match original.kind {
44
+ ParseErrorKind::Basic(err) => SelectorErrorKind::from(err),
45
+ ParseErrorKind::Custom(err) => SelectorErrorKind::from(err),
46
+ }
47
+ }
48
+ }
49
+
50
+ impl<'a> From<BasicParseErrorKind<'a>> for SelectorErrorKind<'a> {
51
+ fn from(err: BasicParseErrorKind<'a>) -> Self {
52
+ match err {
53
+ BasicParseErrorKind::UnexpectedToken(token) => Self::UnexpectedToken(token),
54
+ BasicParseErrorKind::EndOfInput => Self::EndOfLine,
55
+ BasicParseErrorKind::AtRuleInvalid(rule) => Self::InvalidAtRule(rule.to_string()),
56
+ BasicParseErrorKind::AtRuleBodyInvalid => Self::InvalidAtRuleBody,
57
+ BasicParseErrorKind::QualifiedRuleInvalid => Self::QualRuleInvalid,
58
+ }
59
+ }
60
+ }
61
+
62
+ impl<'a> From<SelectorParseErrorKind<'a>> for SelectorErrorKind<'a> {
63
+ fn from(err: SelectorParseErrorKind<'a>) -> Self {
64
+ match err {
65
+ SelectorParseErrorKind::PseudoElementExpectedColon(token) => {
66
+ Self::ExpectedColonOnPseudoElement(token)
67
+ }
68
+ SelectorParseErrorKind::PseudoElementExpectedIdent(token) => {
69
+ Self::ExpectedIdentityOnPseudoElement(token)
70
+ }
71
+ other => Self::UnexpectedSelectorParseError(other),
72
+ }
73
+ }
74
+ }
75
+
76
+ impl Display for SelectorErrorKind<'_> {
77
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78
+ write!(
79
+ f,
80
+ "{}",
81
+ match self {
82
+ Self::UnexpectedToken(token) => {
83
+ format!("Token {:?} was not expected", utils::render_token(token))
84
+ }
85
+ Self::EndOfLine => "Unexpected EOL".to_string(),
86
+ Self::InvalidAtRule(rule) => format!("Invalid @-rule {rule:?}"),
87
+ Self::InvalidAtRuleBody => "The body of an @-rule was invalid".to_string(),
88
+ Self::QualRuleInvalid => "The qualified name was invalid".to_string(),
89
+ Self::ExpectedColonOnPseudoElement(token) => format!(
90
+ "Expected a ':' token for pseudoelement, got {:?} instead",
91
+ utils::render_token(token)
92
+ ),
93
+ Self::ExpectedIdentityOnPseudoElement(token) => format!(
94
+ "Expected identity for pseudoelement, got {:?} instead",
95
+ utils::render_token(token)
96
+ ),
97
+ Self::UnexpectedSelectorParseError(err) => format!(
98
+ "Unexpected error occurred. Please report this to the developer\n{err:#?}"
99
+ ),
100
+ }
101
+ )
102
+ }
103
+ }
104
+
105
+ impl Error for SelectorErrorKind<'_> {
106
+ fn description(&self) -> &str {
107
+ match self {
108
+ Self::UnexpectedToken(_) => "Token was not expected",
109
+ Self::EndOfLine => "Unexpected EOL",
110
+ Self::InvalidAtRule(_) => "Invalid @-rule",
111
+ Self::InvalidAtRuleBody => "The body of an @-rule was invalid",
112
+ Self::QualRuleInvalid => "The qualified name was invalid",
113
+ Self::ExpectedColonOnPseudoElement(_) => "Missing colon character on pseudoelement",
114
+ Self::ExpectedIdentityOnPseudoElement(_) => "Missing pseudoelement identity",
115
+ Self::UnexpectedSelectorParseError(_) => "Unexpected error",
116
+ }
117
+ }
118
+ }