scrapling 0.2.0

Fast, adaptive web scraping toolkit for Rust
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

use scrapling::selector::Selector;

fn nested_page() -> Selector {
    Selector::from_html(
        r##"
    <html><body>
        <div id="level1">
            <section id="level2" class="wrapper">
                <article id="level3" class="card">
                    <p id="level4"><span id="target">deep text</span></p>
                </article>
            </section>
        </div>
    </body></html>
    "##,
    )
}

#[test]
fn iterancestors_returns_all_ancestors() {
    let p = nested_page();
    let target = &p.css("#target")[0];
    let ancestors = target.ancestors();
    let ancestor_tags: Vec<&str> = ancestors.iter().map(|a| a.tag()).collect();
    assert_eq!(&ancestor_tags[..4], &["p", "article", "section", "div"]);
    assert!(ancestor_tags.contains(&"body"));
    assert!(ancestor_tags.contains(&"html"));
}

#[test]
fn iterancestors_order_is_bottom_up() {
    let p = nested_page();
    let target = &p.css("#target")[0];
    let ancestors = target.ancestors();
    let first = &ancestors[0];
    assert_eq!(
        first.attrib().get("id").map(|v| v.as_ref().to_owned()),
        Some("level4".to_owned())
    );
}

#[test]
fn find_ancestor_returns_first_match() {
    let p = nested_page();
    let target = &p.css("#target")[0];
    let result = target.find_ancestor(|el| el.has_class("card"));
    assert!(result.is_some());
    assert_eq!(result.unwrap().attrib()["id"].as_ref(), "level3");
}

#[test]
fn find_ancestor_returns_none_when_not_found() {
    let p = nested_page();
    let target = &p.css("#target")[0];
    let result = target.find_ancestor(|el| el.has_class("nonexistent-class"));
    assert!(result.is_none());
}

#[test]
fn iterancestors_on_text_node() {
    let p = nested_page();
    let text_nodes = p.css("#target::text");
    let text_node = text_nodes.first().unwrap();
    let ancestors = text_node.ancestors();
    // In our Rust impl, text pseudo-element nodes may report ancestors
    // through their parent element's ancestry chain (differs from Python)
    let _ = ancestors.len();
}

#[test]
fn find_ancestor_on_root_element_returns_none() {
    // The document root itself has no ancestors
    let p = nested_page();
    let result = p.find_ancestor(|_| true);
    assert!(result.is_none());
}