mintyml 0.1.19

A minialist alternative syntax to HTML
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

use alloc::vec;
use core::mem;

use gramma::parse::LocationRange;

use crate::{
    document::{Document, Element, ElementType, Node, NodeType, Space},
    error::InternalResult,
};

/// Tags that generally belong in a `<head>` element.
const METADATA_TAGS: &[&str] = &["base", "link", "meta", "title", "style"];

/// If `node` is an element whose tag is contained in `tags`, returns a reference to the [Element] value.
fn extract_element_with_tag_in<'node, 'src, I: Iterator + Clone>(
    src: &str,
    node: &'node mut Node<'src>,
    tags: impl IntoIterator<IntoIter = I>,
) -> Option<&'node mut Element<'src>>
where
    I::Item: AsRef<str>,
{
    let tags = tags.into_iter();
    let e = node.as_element_mut()?;

    let tag = e.selectors.first()?.tag.name()?;

    if !tags
        .clone()
        .any(|t| tag.as_str(src).eq_ignore_ascii_case(t.as_ref()))
    {
        return None;
    }

    Some(e)
}

/// Determines whether `node` is an element whose tag is contained in `tags`.
fn has_tag_in<'node, 'src, I: Iterator + Clone>(
    src: &str,
    node: &'node mut Node<'src>,
    tags: impl IntoIterator<IntoIter = I>,
) -> bool
where
    I::Item: AsRef<str>,
{
    extract_element_with_tag_in(src, node, tags).is_some()
}

/// Transforms `doc` so that its nodes are wrapped in `<html>` tags with a `<head>` and `<body>`
pub fn complete_page<'cfg>(mut doc: Document<'cfg>, src: &str) -> InternalResult<Document<'cfg>> {
    if doc
        .content
        .nodes
        .iter_mut()
        .any(|n| has_tag_in(src, n, ["html"]))
    {
        // There's already an <html> tag so no need to restructure.
        return Ok(doc);
    }

    let mut root = Element::new(LocationRange::INVALID, ElementType::Unknown {}).with_tag("html");
    root.content.range = doc.content.range;

    if doc
        .content
        .nodes
        .iter_mut()
        .any(|n| has_tag_in(src, n, ["body"]))
    {
        // There's already a body tag so just wrap it all in <html> and call it good.
        root.content.nodes = doc.content.nodes
    } else {
        let mut head =
            Element::new(LocationRange::INVALID, ElementType::Unknown {}).with_tag("head");
        let mut body =
            Element::new(LocationRange::INVALID, ElementType::Unknown {}).with_tag("body");

        body.content.nodes = doc
            .content
            .nodes
            .into_iter()
            .filter_map(|mut n| {
                if let Some(e) = extract_element_with_tag_in(src, &mut n, ["head"]) {
                    head.content.nodes.extend(mem::take(&mut e.content.nodes));
                    None
                } else if has_tag_in(src, &mut n, METADATA_TAGS) {
                    head.content.nodes.push(n);
                    None
                } else {
                    Some(n)
                }
            })
            .collect();

        root.content.nodes = vec![
            head.into(),
            Node {
                range: LocationRange::INVALID,
                node_type: NodeType::TextLike {
                    text_like: Space::ParagraphEnd {}.into(),
                },
            },
            body.into(),
        ];
    }

    doc.content.nodes = vec![root.into()];
    Ok(doc)
}