jsonrepair 0.1.0

Fast, low-dependency JSON repair for Rust. Turns 'almost JSON' into valid JSON; supports streaming and writer-based output.
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

use super::*;

#[test]
fn ns_concat_various_cases_table() {
    let cases = vec![
        ("\"a\" + \"b\"", "\"ab\""),
        ("'a' + ' ' + 'b'", "\"a b\""),
        ("'x' + /*c*/ 'y'", "\"xy\""),
    ];
    for (inp, want) in cases {
        let out = crate::repair_to_string(inp, &Options::default()).unwrap();
        assert_eq!(out, want, "input={}", inp);
    }
}

#[test]
fn ns_string_ensure_ascii_toggle() {
    let s = "'你好'";
    let out1 = crate::repair_to_string(s, &Options::default()).unwrap();
    let v1: serde_json::Value = serde_json::from_str(&out1).unwrap();
    assert_eq!(v1, serde_json::json!("你好"));
    let o = Options {
        ensure_ascii: true,
        ..Default::default()
    };
    let out2 = crate::repair_to_string(s, &o).unwrap();
    assert!(out2.contains("\\u"));
}

#[test]
fn ns_concat_with_escaped_quotes() {
    let s = "\"a\\\"b\" + ' c'"; // "a\"b" + ' c'
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v, serde_json::json!("a\"b c"));
}

#[test]
fn ns_concat_three_parts_with_unicode_and_comments() {
    let s = "'你好' + /*c*/ ' ' + '世界'";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v, serde_json::json!("你好 世界"));
}

#[test]
fn ns_regex_with_flags_becomes_string() {
    let s = "{r:/ab+/i}";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    let obj = v.as_object().expect("object");
    let r = obj.get("r").and_then(|x| x.as_str()).expect("string");
    assert!(r == "/ab+/i" || r == "/ab+/");
    if let Some(extra) = obj.get("i") {
        assert!(extra.is_null() || extra.is_string());
    }
}

#[test]
fn ns_concat_mixed_quotes_and_spaces() {
    let s = "\"a\"+ 'b' ";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v, serde_json::json!("ab"));
}

#[test]
fn ns_concat_with_many_segments() {
    let s = "'a' + 'b' + 'c' + 'd'";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v, serde_json::json!("abcd"));
}

#[test]
fn ns_concat_empty_segments_collapse() {
    let s = "'a' + '' + 'b'";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v, serde_json::json!("ab"));
}

#[test]
fn ns_regex_unknown_flag_tolerant() {
    let s = "{r:/ab+/g}";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    let obj = v.as_object().unwrap();
    let r = obj.get("r").and_then(|x| x.as_str()).unwrap_or("");
    assert!(r.contains("/ab+/"));
}

#[test]
fn ns_concat_with_newlines_and_plus() {
    let s = "'a'\n+ 'b'";
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v, serde_json::json!("ab"));
}

#[test]
fn ns_regex_edge_escapes_in_object() {
    // Ensure regex with escaped slash remains a single string token
    let s = "{r:/a\\//}"; // /a\//
    let out = crate::repair_to_string(s, &Options::default()).unwrap();
    let v: serde_json::Value = serde_json::from_str(&out).unwrap();
    let r = v.get("r").and_then(|x| x.as_str()).unwrap();
    assert!(r == "/a\\//" || r == "/a//");
}

#[test]
fn ns_concat_unicode_ensure_ascii() {
    let s = "'��' + '��'";
    let o = Options {
        ensure_ascii: true,
        ..Default::default()
    };
    let out = crate::repair_to_string(s, &o).unwrap();
    assert!(out.contains("\\u"));
}