tryparse 0.4.4

Multi-strategy parser for messy real-world data. Handles broken JSON, markdown wrappers, and type mismatches.
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

use serde::Deserialize;
use tryparse::parse;

#[derive(Deserialize, Debug)]
struct User {
    name: String,
    age: u32,
}

#[test]
fn test_zero_width_space() {
    // Zero-width space (U+200B) in the JSON
    let response = "{\"name\u{200B}\": \"Alice\", \"age\": 30}";
    let result: Result<User, _> = parse(response);
    assert!(result.is_ok(), "Should handle zero-width spaces");
    let user = result.unwrap();
    assert_eq!(user.name, "Alice");
    assert_eq!(user.age, 30);
}

#[test]
fn test_bom_at_start() {
    // BOM (Byte Order Mark) at the beginning
    let response = "\u{FEFF}{\"name\": \"Bob\", \"age\": 25}";
    let result: Result<User, _> = parse(response);
    assert!(result.is_ok(), "Should handle BOM at start");
    let user = result.unwrap();
    assert_eq!(user.name, "Bob");
    assert_eq!(user.age, 25);
}

#[test]
fn test_zero_width_non_joiner() {
    // Zero-width non-joiner (U+200C)
    let response = "{\"na\u{200C}me\": \"Charlie\", \"age\": 35}";
    let result: Result<User, _> = parse(response);
    assert!(result.is_ok(), "Should handle zero-width non-joiner");
    let user = result.unwrap();
    assert_eq!(user.name, "Charlie");
    assert_eq!(user.age, 35);
}

#[test]
fn test_multiple_invisible_chars() {
    // Multiple invisible characters
    let response = "\u{FEFF}{\"name\u{200B}\": \"Dave\u{200C}\", \"age\u{200D}\": 40}";
    let result: Result<User, _> = parse(response);
    assert!(
        result.is_ok(),
        "Should handle multiple invisible characters"
    );
    let user = result.unwrap();
    assert_eq!(user.name, "Dave");
    assert_eq!(user.age, 40);
}

#[test]
fn test_rtl_marks() {
    // Right-to-left and left-to-right marks
    let response = "{\"name\u{200E}\": \"Eve\u{200F}\", \"age\": 45}";
    let result: Result<User, _> = parse(response);
    assert!(result.is_ok(), "Should handle RTL/LTR marks");
    let user = result.unwrap();
    assert_eq!(user.name, "Eve");
    assert_eq!(user.age, 45);
}

#[test]
fn test_clean_json_unaffected() {
    // Clean JSON should still work
    let response = r#"{"name": "Frank", "age": 50}"#;
    let result: Result<User, _> = parse(response);
    assert!(result.is_ok(), "Clean JSON should still work");
    let user = result.unwrap();
    assert_eq!(user.name, "Frank");
    assert_eq!(user.age, 50);
}