struson 0.7.2

A low-level streaming JSON reader and writer
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

use std::{error::Error, io::Read};

use assert_no_alloc::permit_alloc;
// Only use import when creating debug builds, see also configuration below
#[cfg(debug_assertions)]
use assert_no_alloc::AllocDisabler;
use struson::{
    json_path,
    reader::{JsonReader, JsonStreamReader, ReaderSettings},
    writer::{JsonStreamWriter, JsonWriter},
};

// Only enable when creating debug builds
#[cfg(debug_assertions)]
#[global_allocator]
static A: AllocDisabler = AllocDisabler;

fn assert_no_alloc<F: FnOnce() -> Result<(), Box<dyn Error>>>(func: F) {
    assert_no_alloc::assert_no_alloc(func).unwrap()
}

fn permit_dealloc<T, F: FnOnce() -> T>(func: F) -> T {
    // TODO: Permitting only dealloc is not possible yet, see https://github.com/Windfisch/rust-assert-no-alloc/issues/15
    permit_alloc(func)
}

fn new_reader(json: &str) -> JsonStreamReader<&[u8]> {
    JsonStreamReader::new_custom(
        json.as_bytes(),
        ReaderSettings {
            // Disable path tracking because that causes allocations
            track_path: false,
            ..Default::default()
        },
    )
}

#[test]
fn skip() {
    let json =
        r#"{"a": [{"b": 1, "c": [[], [2, {"d": 3, "e": "some string value"}]]}], "f": true}"#;
    let mut json_reader = new_reader(json);

    assert_no_alloc(|| {
        json_reader.skip_value()?;

        permit_dealloc(|| json_reader.consume_trailing_whitespace())?;
        Ok(())
    });
}

#[test]
fn read_values() {
    let json = "{\"a\": [\"string\", \"\u{1234}\u{10FFFF}\", 1234.5e+6, true, false, null]}";
    let mut json_reader = new_reader(json);

    assert_no_alloc(|| {
        json_reader.begin_object()?;
        assert_eq!("a", json_reader.next_name()?);
        json_reader.begin_array()?;

        assert_eq!("string", json_reader.next_str()?);
        assert_eq!("\u{1234}\u{10FFFF}", json_reader.next_str()?);
        assert_eq!("1234.5e+6", json_reader.next_number_as_str()?);
        assert_eq!(true, json_reader.next_bool()?);
        assert_eq!(false, json_reader.next_bool()?);
        json_reader.next_null()?;

        json_reader.end_array()?;
        json_reader.end_object()?;
        permit_dealloc(|| json_reader.consume_trailing_whitespace())?;
        Ok(())
    });
}

#[test]
fn read_string_escape_sequences() {
    let json = r#"["\n", "\t a", "a \u1234", "a \uDBFF\uDFFF b"]"#;
    let mut json_reader = new_reader(json);

    assert_no_alloc(|| {
        json_reader.begin_array()?;
        // These don't cause allocation because the internal value buffer has already
        // been allocated when the JSON reader was created, and is then reused
        assert_eq!("\n", json_reader.next_str()?);
        assert_eq!("\t a", json_reader.next_str()?);
        assert_eq!("a \u{1234}", json_reader.next_str()?);
        assert_eq!("a \u{10FFFF} b", json_reader.next_str()?);

        json_reader.end_array()?;
        permit_dealloc(|| json_reader.consume_trailing_whitespace())?;
        Ok(())
    });
}

#[test]
fn string_value_reader() -> Result<(), Box<dyn Error>> {
    let repetition_count = 100;
    let json_string_value = "\\n \\t a \\u1234 \\uDBFF\\uDFFF \u{10FFFF}".repeat(repetition_count);
    let expected_string_value = "\n \t a \u{1234} \u{10FFFF} \u{10FFFF}".repeat(repetition_count);
    let json = format!("\"{json_string_value}\"");
    let mut json_reader = new_reader(&json);

    // Pre-allocate with expected size to avoid allocations during test execution
    let mut string_output = String::with_capacity(expected_string_value.len());

    assert_no_alloc(|| {
        let mut string_value_reader = json_reader.next_string_reader()?;
        string_value_reader.read_to_string(&mut string_output)?;
        drop(string_value_reader);

        permit_dealloc(|| json_reader.consume_trailing_whitespace())?;
        Ok(())
    });

    assert_eq!(expected_string_value, string_output);
    Ok(())
}

#[test]
fn transfer_to() -> Result<(), Box<dyn Error>> {
    let inner_json = r#"{"a":[{"b":1,"c":[[],[2,{"d":3,"e":"some string value"}]]}],"f":true}"#;
    let json = "{\"outer-ignored\": 1, \"outer\":[\"ignored\", ".to_owned() + inner_json + "]}";
    let mut json_reader = new_reader(&json);

    // Pre-allocate with expected size to avoid allocations during test execution
    let mut writer = Vec::<u8>::with_capacity(inner_json.len());
    let mut json_writer = JsonStreamWriter::new(&mut writer);

    let json_path = json_path!["outer", 1];

    assert_no_alloc(|| {
        json_reader.seek_to(&json_path)?;

        json_reader.transfer_to(&mut json_writer)?;
        permit_dealloc(|| json_writer.finish_document())?;

        json_reader.skip_to_top_level()?;
        permit_dealloc(|| json_reader.consume_trailing_whitespace())?;
        Ok(())
    });

    assert_eq!(inner_json, String::from_utf8(writer)?);
    Ok(())
}