html-cat 0.1.0

HTML5 parser: tokenizer + tree builder producing a Document tree of Element/Text/Comment nodes. No mut, no Rc/Arc, no interior mutability, no panics, exhaustive matches. First sub-crate of a Servo-replacement webview runtime targeting Tauri.
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

//! Element attributes.

/// A name/value attribute pair on an element.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Attribute {
    name: String,
    value: String,
}

impl Attribute {
    /// Build an attribute.  Names are stored as-is (HTML attributes are
    /// ASCII-case-insensitive but we preserve the source form).
    #[must_use]
    pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            value: value.into(),
        }
    }

    /// The attribute name.
    #[must_use]
    pub fn name(&self) -> &str {
        &self.name
    }

    /// The attribute value.  Empty for valueless attributes (`<input disabled>`).
    #[must_use]
    pub fn value(&self) -> &str {
        &self.value
    }
}

impl std::fmt::Display for Attribute {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.value.is_empty() {
            write!(f, "{}", self.name)
        } else {
            write!(f, "{}=\"{}\"", self.name, self.value)
        }
    }
}

/// An ordered collection of attributes on an element.  Order is
/// preserved (source order); duplicate names keep the first occurrence
/// per the HTML5 spec.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Attributes {
    items: Vec<Attribute>,
}

impl Attributes {
    /// An empty attribute set.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Build from a vector, dropping duplicate names (later entries).
    #[must_use]
    pub fn from_iter_dedup<I: IntoIterator<Item = Attribute>>(items: I) -> Self {
        let mut seen = std::collections::BTreeSet::new();
        let deduped = items
            .into_iter()
            .filter(|a| seen.insert(a.name().to_owned()))
            .collect();
        Self { items: deduped }
    }

    /// Append `attribute`; no-op if the name already exists (first wins
    /// per HTML5 attribute-parsing rules).
    #[must_use]
    pub fn with(self, attribute: Attribute) -> Self {
        if self.items.iter().any(|a| a.name() == attribute.name()) {
            self
        } else {
            let extended: Vec<Attribute> = self
                .items
                .into_iter()
                .chain(std::iter::once(attribute))
                .collect();
            Self { items: extended }
        }
    }

    /// All attributes in source order.
    pub fn iter(&self) -> std::slice::Iter<'_, Attribute> {
        self.items.iter()
    }

    /// Look up an attribute by name.  HTML attribute names are
    /// case-insensitive; this comparison is ASCII-case-insensitive.
    #[must_use]
    pub fn get(&self, name: &str) -> Option<&Attribute> {
        self.items
            .iter()
            .find(|a| a.name().eq_ignore_ascii_case(name))
    }

    /// Whether the set is empty.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    /// Number of attributes.
    #[must_use]
    pub fn len(&self) -> usize {
        self.items.len()
    }
}

impl<'a> IntoIterator for &'a Attributes {
    type Item = &'a Attribute;
    type IntoIter = std::slice::Iter<'a, Attribute>;
    fn into_iter(self) -> Self::IntoIter {
        self.items.iter()
    }
}

impl std::fmt::Display for Attributes {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let body = self
            .items
            .iter()
            .map(|a| format!("{a}"))
            .collect::<Vec<_>>()
            .join(" ");
        f.write_str(&body)
    }
}