hatmel 0.2.0

HTML model and parser (html5ever)
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
114
115
116
117
118
119

#[cfg(feature = "fashion")]
mod fashion;
mod model;
mod navigate;
mod parse;

pub use self::model::*;
pub use self::navigate::*;
use self::parse::*;

use std::borrow::Cow;
use std::marker::PhantomData;
use std::{
    collections::HashMap,
    sync::{atomic::AtomicUsize, Arc},
};

#[derive(Debug, Clone)]
pub struct Hatmel {
    nodes: Vec<Node>,
    children: HashMap<Handle, Vec<Handle>>,
    parents: HashMap<Handle, Handle>,
    mode: QuirksMode,
    revision: usize,
}
impl Default for Hatmel {
    fn default() -> Self {
        let fragment = Node::new_fragment();
        let mut me = Self {
            nodes: Default::default(),
            children: Default::default(),
            parents: Default::default(),
            mode: QuirksMode::NoQuirks,
            revision: 0,
        };
        me.register(fragment);
        me
    }
}
impl Hatmel {
    pub fn revision(&self) -> usize {
        self.revision
    }
    pub fn nodes(&self) -> HandleIter {
        HandleIter::new(0..self.nodes.len())
    }
    /// internal method to register new nodes in the tree
    fn register(&mut self, node: Node) -> Handle {
        let handle = self.nodes.len();
        // TODO: check capacity
        self.nodes.push(node);
        handle
    }
}
#[derive(Default, Debug, Clone)]
struct Node {
    pub content: Content,
    //namespaces: HashMap<Cow<'static, str>, Cow<'static, str>>,
}

impl Node {
    fn new_element(
        name: LocalName,
        namespace: Namespace,
        prefix: Option<Prefix>,
        attrs: Vec<Attribute>,
        kind: ElementKind,
    ) -> Node {
        let content = Content::Element(Element {
            name,
            namespace,
            prefix,
            attrs,
            kind,
        });
        Node { content }
    }

    fn new_comment(text: impl Into<String>) -> Node {
        Node {
            content: Content::Comment { text: text.into() },
        }
    }

    fn new_processing_instruction(target: impl Into<String>, data: impl Into<String>) -> Node {
        Node {
            content: Content::ProcessingInstruction {
                target: target.into(),
                data: data.into(),
            },
        }
    }

    fn new_text(text: impl Into<String>) -> Node {
        Node {
            content: Content::Text { text: text.into() },
        }
    }

    fn new_fragment() -> Node {
        Node {
            content: Content::Document,
        }
    }

    fn new_doctype(
        name: impl Into<String>,
        public_id: impl Into<String>,
        system_id: impl Into<String>,
    ) -> Node {
        Node {
            content: Content::DocType {
                name: name.into(),
                public_id: public_id.into(),
                system_id: system_id.into(),
            },
        }
    }
}