html-filter 0.2.3

Parse HTML into a typed tree, then search for tags, attributes, classes, filter out comments or find and extract the exact data you want with a short builder pattern - zero dependencies, zero overhead
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

/// Test expected parsing errors.
pub mod errors;
/// Test filters on index.html.
pub mod filter;
/// Test finders on index.html.
pub mod find;
/// Test no filter keeps html intact.
pub mod full;
/// Test that ana html is parsed correctly.
pub mod matches;
/// Test filters on a smaller string.
pub mod strings;
/// Test the trimming mechanism.
pub mod trim;

use core::fmt::Debug;
use std::fs;

use html_filter::*;

fn handle_auto_closing(html: &str) -> String {
    let mut output = String::with_capacity(html.len());
    let mut tag_name = String::new();
    let mut reading = false;
    let mut last_slash = false;
    for ch in html.chars() {
        if ch == '>' && last_slash {
            output.push_str("> </");
            output.push_str(&tag_name);
            output.push('>');
            tag_name.clear();
            last_slash = false;
            reading = false;
        } else if ch == '/' {
            if last_slash {
                output.push('/');
            } else {
                last_slash = true;
            }
            reading = false;
        } else {
            if last_slash {
                last_slash = false;
                output.push('/');
            }
            if ch == '<' {
                reading = true;
                tag_name.clear();
                output.push('<');
            } else {
                if ch.is_whitespace() || ch == '!' || ch == '>' {
                    reading = false;
                }
                output.push(ch);
                if reading {
                    tag_name.push(ch);
                }
            }
        }
    }
    output
}

fn format_html(html: &str) -> String {
    let mut formatted = html
        .replace('/', " /")
        .replace('\n', " ")
        .replace("< ", "<")
        .replace(" >", ">")
        .replace('<', " <")
        .replace('>', "> ");
    loop {
        let out = formatted.replace("  ", " ");
        if out == formatted {
            break;
        }
        formatted = out;
    }
    handle_auto_closing(&formatted)
        .replace(" >", ">")
        .replace("> </meta>", ">")
        .replace("> </br>", ">")
}

fn test_maker<T: Debug>(
    name: &str,
    expected_str: &str,
    output_html: &Html,
    msg: T,
    simplify: bool,
) {
    let (formatted_input, formatted_output) = if simplify {
        (format_html(expected_str), format_html(&output_html.to_string()))
    } else {
        (expected_str.to_owned(), output_html.to_string())
    };
    if formatted_output != formatted_input {
        let output_path = format!("output.{name}.html");
        let expected_path = format!("expected.{name}.html");
        fs::write(&output_path, formatted_output.replace(' ', "\n"))
            .expect("Permission denied: failed to write to directory.");
        fs::write(&expected_path, formatted_input.replace(' ', "\n"))
            .expect("Permission denied: failed to write to directory.");
        let sep = format!("\n\x1b[33m{}\x1b[0m\n", "-".repeat(50));
        let nl = "\n";
        let output = "\x1b[33mOutput:\x1b[0m";
        let expected = "\x1b[33mExpected:\x1b[0m";
        panic!(
            "{msg:?}\n{output}{sep}.{formatted_output}.{sep}{nl}{expected}{sep}.{formatted_input}.\
             {sep}Use `diff {output_path} {expected_path}` to see the problem."
        );
    }
}