dom_query 0.27.0

HTML querying and manipulation with CSS selectors
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

mod data;

use std::collections::HashSet;

use data::{doc, ANCESTORS_CONTENTS, HEADING_CONTENTS};

use dom_query::{Document, Selection};
#[cfg(target_arch = "wasm32")]
use wasm_bindgen_test::*;

mod alloc;

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is() {
    let doc = doc();
    let sel = doc.select(".footer p:nth-child(1)");
    assert!(sel.is("p"), "Expected .footer p:nth-child(1) to be a p.");
    assert!(!doc.select("#non-existing").is("#non-existing"));
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is_invalid() {
    let doc = doc();
    let sel = doc.select(".footer p:nth-child(1)");
    assert!(
        !sel.is(""),
        "is should not succeed with invalid selector string"
    );
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is_selection() {
    let doc = doc();
    let sel = doc.select("div");
    let sel2 = doc.select(".pvk-gutter");

    assert!(
        sel.is_selection(&sel2),
        "Expected some div to have a pvk-gutter class."
    );
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is_selection_not() {
    let doc = doc();
    let sel = doc.select("div");
    let sel2 = doc.select("a");

    assert!(
        !sel.is_selection(&sel2),
        "Expected some div NOT to be an anchor."
    );
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_filter_selection() {
    let doc: Document = HEADING_CONTENTS.into();
    // we captured 2 divs with `.content` class
    let sel = doc.select("div.content");
    assert!(sel.select("h1").exists());

    // create a new filtered selection, that will contain only elements with `.text-content` class
    let filtered_sel = sel.filter("div.text-content");

    // filtered selection does not contain any `h1`
    assert!(!filtered_sel.select("h1").exists());
    // while original selection contains `h1`
    assert!(sel.select("h1").exists());
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_try_filter_selection() {
    let doc: Document = HEADING_CONTENTS.into();
    // we captured 2 divs with `.content` class
    let sel = doc.select("div.content");
    assert!(sel.select("h1").exists());
    let filtered_sel = sel.try_filter("div.text-content").unwrap();
    assert!(!filtered_sel.select("h1").exists());
    assert!(sel.select("h1").exists());
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_filter_selection_other() {
    let doc: Document = r#"<!DOCTYPE html>
    <html lang="en">
        <head><title>Test</title></head>
        <body>
            <div class="content">
                <p>Content text has a <a href="/0">link</a></p>
            </div>
            <footer>
                <a href="/1">Footer Link</a>
            </footer>
        </body>
    </html>
    "#
    .into();

    // selecting all links in the document
    let sel_with_links = doc.select("a[href]");

    assert_eq!(sel_with_links.length(), 2);
    // selecting every element inside `.content`
    let content_sel = doc.select("div.content *");

    // filter selection by content selection, so now we get only links (actually only 1 link) that are inside `.content`
    let filtered_sel = sel_with_links.filter_selection(&content_sel);

    assert_eq!(filtered_sel.length(), 1);
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is_empty() {
    let doc: Document = ANCESTORS_CONTENTS.into();
    let sel = doc.select("#parent > #first-child");
    assert!(!sel.is_empty());
    assert!(!sel.is("#third-child"));
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is_empty_selection() {
    let doc: Document = ANCESTORS_CONTENTS.into();
    let first_child_sel = doc.select("#parent > #first-child");
    assert!(!first_child_sel.is_empty());

    let third_child_sel = doc.select("#parent > #third-child");
    assert!(third_child_sel.is_empty());

    assert!(!first_child_sel.is_selection(&third_child_sel));
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_is_has() {
    let contents = r#"<!DOCTYPE html>
    <html>
        <body>
            <div><img src="image.png"></div>
            <div id="anchor"></div>
        </body>
    </html>"#;
    let doc: Document = contents.into();
    let sel = doc.select("#anchor");

    let anchor_node = sel.nodes().first().unwrap();

    let prev_sibling = anchor_node.prev_element_sibling().unwrap();
    let prev_sel = Selection::from(prev_sibling);

    assert!(prev_sel.is("*:has( > img:only-child)"));
}

#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
fn test_selection_unique() {
    // This document contains many nested div elements and was taken from the dom_smoothie test data.
    // I was investigating whether an additional uniqueness check during selection was necessary,
    // as the results looked correct and unique without it, while the check added overhead.
    // However, after removing the `set.contains` check from `Matches::next`, the dom_smoothie::Readability tests started failing.
    // Therefore, the current `Matches` implementation requires the uniqueness check despite the overhead.

    let contents = include_str!("../test-pages/002.html");
    let doc: Document = contents.into();

    let div_sel = doc.select(".page").select("div").select("div > div");

    let sel_ids = div_sel.nodes().iter().map(|n| n.id).collect::<Vec<_>>();

    let unique_ids = sel_ids.iter().cloned().collect::<HashSet<_>>();
    assert_eq!(sel_ids.len(), unique_ids.len());
}