kv3 0.2.0

kv3 (keyvalues 3) format parser with serde support
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! chumsky-based parser for the KV3 text format.

use std::collections::HashMap;

use chumsky::error::Rich;
use chumsky::extra;
use chumsky::prelude::*;

use crate::types::{KV3Error, KV3Object, KV3Value};

/// Parse a full KV3 document and return its top-level fields.
///
/// Returns a list of [`KV3Error`] values on failure, each carrying a rendered
/// message and a source span.
pub fn parse_kv3(input: &str) -> Result<HashMap<String, KV3Value>, Vec<KV3Error>> {
    document_parser()
        .parse(input)
        .into_result()
        .map_err(|errs| errs.into_iter().map(KV3Error::from_rich).collect())
}

impl KV3Error {
    fn from_rich(err: Rich<'_, char>) -> Self {
        let span = err.span();
        Self {
            message: err.to_string(),
            span: span.start..span.end,
        }
    }
}

type Extra<'src> = extra::Err<Rich<'src, char>>;

fn document_parser<'src>() -> impl Parser<'src, &'src str, HashMap<String, KV3Value>, Extra<'src>> {
    // --- whitespace + comments (pad) ---
    let line_comment = just("//")
        .then(any().and_is(just('\n').not()).repeated())
        .ignored();
    let block_comment = just("/*")
        .then(any().and_is(just("*/").not()).repeated())
        .then(just("*/"))
        .ignored();
    let xml_comment = just("<!--")
        .then(any().and_is(just("-->").not()).repeated())
        .then(just("-->"))
        .ignored();
    let comment = choice((line_comment, block_comment, xml_comment));
    let ws = any().filter(|c: &char| c.is_whitespace()).ignored();
    let pad = choice((ws, comment)).repeated();

    // --- identifier-style key ---
    let key = any()
        .filter(|c: &char| c.is_alphanumeric() || *c == '_')
        .repeated()
        .at_least(1)
        .to_slice()
        .map(|s: &str| s.to_string());

    // --- recursive value ---
    let value = recursive(|value| {
        let null = just("null").map(|_| KV3Value::Null);
        let bool_t = just("true").map(|_| KV3Value::Bool(true));
        let bool_f = just("false").map(|_| KV3Value::Bool(false));

        // numbers: optional sign, digits, optional .digits, optional e[+-]?digits
        let digits = any()
            .filter(|c: &char| c.is_ascii_digit())
            .repeated()
            .at_least(1);
        let frac = just('.').then(digits);
        let exp = one_of("eE").then(one_of("+-").or_not()).then(digits);
        let number = just('-')
            .or_not()
            .then(digits)
            .then(frac.or_not())
            .then(exp.or_not())
            .to_slice()
            .try_map(|s: &str, span| {
                if s.contains(['.', 'e', 'E']) {
                    s.parse::<f64>()
                        .map(KV3Value::Double)
                        .map_err(|e| Rich::custom(span, e.to_string()))
                } else {
                    s.parse::<i64>()
                        .map(KV3Value::Int)
                        .map_err(|e| Rich::custom(span, e.to_string()))
                }
            });

        // strings: prefer triple-quoted, fall back to single
        let multi_str = just("\"\"\"")
            .ignore_then(any().and_is(just("\"\"\"").not()).repeated().to_slice())
            .then_ignore(just("\"\"\""))
            .map(|s: &str| KV3Value::String(s.to_string()));
        let single_str = just('"')
            .ignore_then(none_of('"').repeated().to_slice())
            .then_ignore(just('"'))
            .map(|s: &str| KV3Value::String(s.to_string()));
        let string = multi_str.or(single_str);

        // hex array: #[ ff fe ... ]
        let hex_array = just("#[")
            .ignore_then(none_of(']').repeated().to_slice())
            .then_ignore(just(']'))
            .map(|s: &str| {
                let bytes: Vec<u8> = s
                    .split_whitespace()
                    .filter_map(|h| u8::from_str_radix(h, 16).ok())
                    .collect();
                KV3Value::HexArray(bytes)
            });

        // array: `[ pad ( value pad (, pad)? )* ]`
        // Padding only at boundaries so empty `[]`/`[ ]` and trailing-comma cases
        // don't trigger consumption-after-failure in `repeated`/`separated_by`.
        let array_elem = value
            .clone()
            .then_ignore(pad)
            .then_ignore(just(',').then_ignore(pad).or_not());
        let array = pad
            .ignore_then(array_elem.repeated().collect::<Vec<_>>())
            .delimited_by(just('['), just(']'))
            .map(KV3Value::Array);

        // object: `{ pad ( kv pad )* }`
        let kv = key
            .then_ignore(pad)
            .then_ignore(just('='))
            .then_ignore(pad)
            .then(value.clone());
        let object = pad
            .ignore_then(kv.then_ignore(pad).repeated().collect::<Vec<_>>())
            .delimited_by(just('{'), just('}'))
            .map(|fields| KV3Value::Object(KV3Object::new(fields.into_iter().collect())));

        choice((
            array, hex_array, object, null, bool_t, bool_f, number, string,
        ))
    });

    // --- top-level: same shape as `object`, but returns a HashMap directly ---
    let top_kv = key
        .then_ignore(pad)
        .then_ignore(just('='))
        .then_ignore(pad)
        .then(value);

    pad.ignore_then(top_kv.then_ignore(pad).repeated().collect::<Vec<_>>())
        .delimited_by(just('{'), just('}'))
        .padded_by(pad)
        .then_ignore(end())
        .map(|kvs| kvs.into_iter().collect())
}