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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

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

use crate::parser::{
    HsmlProcessContext, HsmlResult, Span, advance, delimited_section_len,
    error::{ErrorCode, HsmlError},
    quoted_string_len, take_prefix,
};

fn is_valid_attribute_key_start(c: char) -> bool {
    c.is_alphabetic() || c == ':' || c == '#' || c == '@' || c == '[' || c == '('
}

/// Returns true if the character is a valid attribute key character.
/// Brackets and parentheses are handled separately as delimited sections.
fn is_key_char(c: char) -> bool {
    c.is_alphanumeric() || matches!(c, '-' | '_' | ':' | '#' | '@' | '.' | '{' | '}')
}

pub(super) fn process_attribute_key(input: Span<'_>) -> HsmlResult<'_, Span<'_>> {
    let Some(first_char) = input.fragment().chars().next() else {
        return Err(HsmlError::fail_code(input, ErrorCode::InvalidAttributeKey));
    };

    if first_char.is_numeric() {
        return Err(HsmlError::fail_code(input, ErrorCode::InvalidAttributeKey));
    }

    if !is_valid_attribute_key_start(first_char) {
        return Err(HsmlError::fail_code(input, ErrorCode::InvalidAttributeKey));
    }

    let mut remaining = input;
    let mut key_len = 0;

    loop {
        // Consume regular key characters (allowlist-based)
        if let Ok((rest, taken)) = take_while1::<_, Span, HsmlError>(is_key_char)(remaining) {
            key_len += taken.fragment().len();
            remaining = rest;
            continue;
        }

        // Check for bracket section [...]
        if remaining.fragment().starts_with('[') {
            if let Some(len) = delimited_section_len(remaining.fragment(), '[', ']') {
                key_len += len;
                remaining = advance(input, key_len);
                continue;
            }
            return Err(HsmlError::fail_code(remaining, ErrorCode::UnclosedBracket));
        }

        // Check for parenthesized section (...)
        if remaining.fragment().starts_with('(') {
            if let Some(len) = delimited_section_len(remaining.fragment(), '(', ')') {
                key_len += len;
                remaining = advance(input, key_len);
                continue;
            }
            return Err(HsmlError::fail_code(
                remaining,
                ErrorCode::UnclosedParenthesis,
            ));
        }

        // Any other character is a delimiter — stop
        break;
    }

    let attribute_key = take_prefix(input, key_len);

    Ok((remaining, attribute_key))
}

pub(super) fn process_attribute_value<'a>(
    input: Span<'a>,
    _context: &mut HsmlProcessContext,
) -> HsmlResult<'a, Span<'a>> {
    let Some(first_char) = input.fragment().chars().next() else {
        return Err(HsmlError::fail_code(
            input,
            ErrorCode::ExpectedAttributeValue,
        ));
    };

    if first_char != '"' && first_char != '\'' {
        return Err(HsmlError::fail_code(
            input,
            ErrorCode::ExpectedAttributeValue,
        ));
    }

    if let Some(len) = quoted_string_len(input.fragment()) {
        // value between quotes (excluding the quotes themselves)
        let attribute_value = take_prefix(advance(input, 1), len - 2);
        let remaining = advance(input, len);

        return Ok((remaining, attribute_value));
    }

    // Unclosed quote
    Err(HsmlError::fail_code(input, ErrorCode::UnclosedQuote))
}

// An attribute key can only contain a-z, A-Z, 0-9, `-`, `_`, `:`, `#`, `@`, `[`, `]`, `(`, `)`, `{`, `}`
// There is the special case that an attribute key can contain a dot (`.`) if it is followed by a letter
// There is the special case that an attribute key can contain a space (` `) if it is surrounded by quotes (`"`)
// Quotes can only contained if they are surrounded by quotes (`"`)
// An attribute key must start with a-z, A-Z, `:`, `#`, `@`, `[`, `(`

// First take until the first potential equal sign (`=`)
//  If there is an equal sign, then test the output for being a valid attribute key
//  If there is no equal sign, then the attribute might be a boolean attribute

// If the attribute is a boolean attribute, then return the attribute and the remaining input

pub(super) fn process_attribute<'a>(
    input: Span<'a>,
    context: &mut HsmlProcessContext,
) -> HsmlResult<'a, Span<'a>> {
    let (remaining, attribute_key) = process_attribute_key(input)?;

    // check if remaining starts with an equal sign
    if let Ok((remaining_after_equal_sign, _)) = tag::<&str, Span, HsmlError>("=")(remaining) {
        let (remaining_after_attribute_value, _attribute_value) =
            process_attribute_value(remaining_after_equal_sign, context)?;

        let consumed = input.fragment().len() - remaining_after_attribute_value.fragment().len();
        let attribute = take_prefix(input, consumed);

        return Ok((remaining_after_attribute_value, attribute));
    }

    Ok((remaining, attribute_key))
}