noyalib 0.0.21

A pure Rust YAML library with zero unsafe code and full serde integration
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

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2026 Noyalib. All rights reserved.

//! Lossless unsigned integers above `i64::MAX`.
//!
//! Run: `cargo run --example lossless_u64 --features lossless-u64`

#[path = "support.rs"]
mod support;

use noyalib::{
    Number, ParserConfig, SerializerConfig, Value, from_str_with_config,
    to_string_value_with_config,
};

#[derive(Debug, serde::Serialize, serde::Deserialize, PartialEq)]
struct Record {
    id: u64,
}

fn main() {
    support::header("noyalib -- lossless u64");

    let parse_cfg = ParserConfig::new().lossless_u64_integers(true);
    // The serializer side has no runtime toggle: when the
    // `lossless-u64` feature is compiled in, `Number::Unsigned` is
    // the emitted variant for values above `i64::MAX`. When the
    // feature is off the variant does not exist. `SerializerConfig`
    // still governs indentation / flow style / etc.
    let ser_cfg = SerializerConfig::new();

    let yaml = format!("id: {}\n", u64::MAX);

    support::task_with_output("parse u64::MAX as Number::Unsigned", || {
        let v: Value = from_str_with_config(&yaml, &parse_cfg).unwrap();
        match &v["id"] {
            Value::Number(Number::Unsigned(n)) => vec![format!("id = Unsigned({n})")],
            other => vec![format!("unexpected: {other:?}")],
        }
    });

    support::task_with_output("round-trip Value through serializer config", || {
        let v: Value = from_str_with_config(&yaml, &parse_cfg).unwrap();
        let emitted = to_string_value_with_config(&v, &ser_cfg).unwrap();
        let reparsed: Value = from_str_with_config(&emitted, &parse_cfg).unwrap();
        vec![
            format!("emitted: {}", emitted.trim()),
            format!(
                "reparsed: {:?}",
                match &reparsed["id"] {
                    Value::Number(Number::Unsigned(n)) => format!("Unsigned({n})"),
                    other => format!("{other:?}"),
                }
            ),
        ]
    });

    support::task_with_output("typed struct field deserialises as u64", || {
        let record: Record = from_str_with_config(&yaml, &parse_cfg).unwrap();
        vec![format!("Record {{ id: {} }}", record.id)]
    });

    support::summary(3);
}