h2s_core 0.18.0

A core part of h2s
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

use crate::html::{HtmlElement, HtmlNode, TextNode};
use crate::parseable::ExtractedValue;
use crate::{Error, Never};
use std::fmt::{Debug, Display};

pub trait ExtractionMethod: Debug + Display {
    type Error: Error;
    type ExtractedValue<N: HtmlElement>: ExtractedValue;

    fn extract<N: HtmlElement>(&self, element: N) -> Result<Self::ExtractedValue<N>, Self::Error>;
}

#[derive(Debug, Clone)]
pub struct NoOp;

impl ExtractionMethod for NoOp {
    type Error = Never;
    type ExtractedValue<N: HtmlElement> = N;

    fn extract<N>(&self, element: N) -> Result<Self::ExtractedValue<N>, Self::Error>
    where
        N: HtmlElement,
    {
        Ok(element)
    }
}

#[derive(Debug, Clone)]
pub struct ExtractInnerText;

impl ExtractionMethod for ExtractInnerText {
    type Error = Never;
    type ExtractedValue<N: HtmlElement> = String;

    fn extract<N>(&self, element: N) -> Result<Self::ExtractedValue<N>, Self::Error>
    where
        N: HtmlElement,
    {
        Ok(element.text_contents())
    }
}

#[derive(Debug, Clone)]
pub struct ExtractAttribute {
    pub name: String,
}

impl ExtractionMethod for ExtractAttribute {
    type Error = AttributeNotFound;
    type ExtractedValue<N: HtmlElement> = String;

    fn extract<N: HtmlElement>(&self, element: N) -> Result<Self::ExtractedValue<N>, Self::Error>
    where
        N: HtmlElement,
    {
        element
            .attribute(&self.name)
            .map(|a| a.to_string())
            .ok_or_else(|| AttributeNotFound {
                name: self.name.clone(),
            })
    }
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct AttributeNotFound {
    pub name: String,
}

/// Extracts nth text node's text
#[derive(Debug)]
pub struct ExtractNthText(pub usize);

impl ExtractionMethod for ExtractNthText {
    type Error = NotFound;
    type ExtractedValue<N: HtmlElement> = String;

    fn extract<N: HtmlElement>(&self, element: N) -> Result<Self::ExtractedValue<N>, Self::Error> {
        dbg!(element.child_nodes());
        element
            .child_nodes()
            .iter()
            .filter_map(|n| match n {
                HtmlNode::Text(text) => Some(text),
                _ => None,
            })
            .map(|t| t.get_text())
            .filter(|s| !s.trim().is_empty())
            .nth(self.0)
            .map(|s| s.trim().to_string())
            .ok_or(NotFound)
    }
}

#[derive(Debug)]
pub struct NotFound;