hsml 0.7.2

A pug-inspired HTML preprocessor
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

use nom::bytes::complete::{tag, take_till};

use crate::common::{Location, Position};
use crate::parser::{
    HsmlNode, HsmlProcessContext, HsmlResult, Span, comment::node::comment_dev_node,
};

use super::process::process_attribute;

#[derive(Debug, Eq, serde::Serialize)]
pub struct AttributeNode {
    pub key: String,
    pub value: Option<String>,
    /// Source location where this attribute appears.
    pub location: Location,
}

// PartialEq only compares key and value so that tests comparing parsed ASTs
// don't need to specify exact location values for every attribute.
impl PartialEq for AttributeNode {
    fn eq(&self, other: &Self) -> bool {
        self.key == other.key && self.value == other.value
    }
}

impl AttributeNode {
    /// Create an AttributeNode with key and value (no source location).
    /// Useful in tests where location is not relevant.
    #[doc(hidden)]
    pub fn new_without_location(key: impl Into<String>, value: Option<impl Into<String>>) -> Self {
        Self {
            key: key.into(),
            value: value.map(|v| v.into()),
            location: Location {
                start: Position { line: 0, column: 0 },
                end: Position { line: 0, column: 0 },
            },
        }
    }
}

pub fn attribute_node<'a>(
    input: Span<'a>,
    context: &mut HsmlProcessContext,
) -> HsmlResult<'a, AttributeNode> {
    let start_span = input;
    let (input, attribute) = process_attribute(input, context)?;
    let location = Location::from_spans(&start_span, &input);

    let attribute_str = *attribute.fragment();
    let equal_sign_index = attribute_str.find('=').unwrap_or(attribute_str.len());
    let (key, value) = attribute_str.split_at(equal_sign_index);

    // Remove surrounding quotes and leading `=` from value
    let value = value
        .strip_prefix(r#"=""#)
        .and_then(|v| v.strip_suffix('"'))
        .map(|v| v.to_string());

    Ok((
        input,
        AttributeNode {
            key: key.to_string(),
            value,
            location,
        },
    ))
}

pub fn attribute_nodes<'a>(
    input: Span<'a>,
    context: &mut HsmlProcessContext,
) -> HsmlResult<'a, Vec<HsmlNode>> {
    let (mut input, _) = tag("(")(input)?;

    let mut nodes: Vec<HsmlNode> = vec![];

    // loop until `)`
    // take until attr starts (trim , and whitespace)
    // collect attr
    // if attr is empty, break
    loop {
        let (remaining, _) = take_till(|c: char| !c.is_whitespace() && c != ',')(input)?;

        if remaining.starts_with(')') {
            input = remaining;
            break;
        }

        // if remaining starts with `//`, it is a dev comment
        if remaining.starts_with("//") {
            let (remaining, comment) = comment_dev_node(remaining)?;
            nodes.push(HsmlNode::Comment(comment));

            input = remaining;
            continue;
        }

        let (remaining, attribute) = attribute_node(remaining, context)?;

        nodes.push(HsmlNode::Attribute(attribute));
        input = remaining;
    }

    let (input, _) = tag(")")(input)?;

    Ok((input, nodes))
}