htmls 0.1.8

This is a library for parsing HTML and extracting HTML elements or text.
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

use super::error::{InterpreterError, InterpreterResult};
use super::result::NodeHandle;
use super::{Interpreter, SelectionResult, html};
use crate::parser::ast::TextNode;

/// Apply text selector
pub fn apply_text_selector(it: &mut Interpreter, text_node: &TextNode) -> InterpreterResult<()> {
    let nodes = it.result.nodes()?;

    let result = match text_node {
        TextNode::Text => extract_text_content(&nodes)?,
        TextNode::Href => extract_href_values(&nodes)?,
        TextNode::Src => extract_src_values(&nodes)?,
        TextNode::AttrValue(name, is_regex) => extract_attr_values(&nodes, name, *is_regex)?,
    };

    it.result = SelectionResult::with_texts(result);

    Ok(())
}

/// Extract text content from nodes
fn extract_text_content(nodes: &Vec<NodeHandle>) -> InterpreterResult<Vec<String>> {
    let mut text_values = Vec::with_capacity(nodes.len());

    for node in nodes {
        match html::extract_text(node) {
            Ok(text) => text_values.push(text),
            Err(err) => {
                return Err(InterpreterError::TextExtractionError(format!(
                    "Unable to extract text content: {}",
                    err
                )));
            }
        }
    }

    Ok(text_values)
}

/// Extract href attribute values from nodes
fn extract_href_values(nodes: &Vec<NodeHandle>) -> InterpreterResult<Vec<String>> {
    let mut href_values = Vec::new();

    for node in nodes {
        match html::get_href(node) {
            Ok(Some(href)) => href_values.push(href),
            Ok(None) => {} // Node has no href attribute, skip
            Err(err) => {
                return Err(InterpreterError::AttributeExtractionError(format!(
                    "Unable to extract href attribute: {}",
                    err
                )));
            }
        }
    }

    Ok(href_values)
}

/// Extract src attribute values from nodes
fn extract_src_values(nodes: &Vec<NodeHandle>) -> InterpreterResult<Vec<String>> {
    let mut src_values = Vec::new();

    for node in nodes {
        match html::get_src(node) {
            Ok(Some(src)) => src_values.push(src),
            Ok(None) => {} // Node has no src attribute, skip
            Err(err) => {
                return Err(InterpreterError::AttributeExtractionError(format!(
                    "Unable to extract src attribute: {}",
                    err
                )));
            }
        }
    }

    Ok(src_values)
}


/// Extract attribute values from nodes
fn extract_attr_values(nodes: &Vec<NodeHandle>, name: &str, is_regex: bool) -> InterpreterResult<Vec<String>> {
    let mut src_values = Vec::new();

    for node in nodes {
        match html::get_attribute(node, name, is_regex){
            Ok(Some(src)) => src_values.push(src),
            Ok(None) => {} // Node has no src attribute, skip
            Err(err) => {
                return Err(InterpreterError::AttributeExtractionError(format!(
                    "Unable to extract src attribute: {}",
                    err
                )));
            }
        }
    }

    Ok(src_values)
}