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
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

//! Tests for implied key inference (single-field struct coercion).
//!
//! BAML algorithm: When deserializing a single-field struct and the value
//! isn't an object, try to coerce the entire value into that single field.

use serde::Deserialize;
use tryparse::parse;
#[cfg(feature = "derive")]
use tryparse::parse_llm;

#[derive(Deserialize, Debug, PartialEq)]
struct Wrapper {
    data: String,
}

#[derive(Deserialize, Debug, PartialEq)]
struct NumberWrapper {
    value: i64,
}

#[test]
#[ignore] // Implied key only works with LlmDeserialize, not serde::Deserialize
fn test_single_field_string_implied_key() {
    // Direct string should wrap into single field
    // NOTE: This requires LlmDeserialize trait, not regular serde::Deserialize
    let response = r#""hello world""#;
    let result: Result<Wrapper, _> = parse(response);
    assert!(result.is_ok(), "Should coerce string into single field");
    let wrapper = result.unwrap();
    assert_eq!(wrapper.data, "hello world");
}

#[test]
#[ignore] // Implied key only works with LlmDeserialize, not serde::Deserialize
fn test_single_field_number_implied_key() {
    // Direct number should wrap into single field
    // NOTE: This requires LlmDeserialize trait, not regular serde::Deserialize
    let response = "42";
    let result: Result<NumberWrapper, _> = parse(response);
    assert!(result.is_ok(), "Should coerce number into single field");
    let wrapper = result.unwrap();
    assert_eq!(wrapper.value, 42);
}

#[test]
fn test_single_field_still_accepts_object() {
    // Single-field structs should still accept proper objects
    let response = r#"{"data": "hello"}"#;
    let result: Result<Wrapper, _> = parse(response);
    assert!(result.is_ok());
    let wrapper = result.unwrap();
    assert_eq!(wrapper.data, "hello");
}

#[test]
#[ignore] // Implied key only works with LlmDeserialize, not serde::Deserialize
fn test_single_field_array_implied_key() {
    #[derive(Deserialize, Debug)]
    struct ArrayWrapper {
        items: Vec<String>,
    }

    // Array should wrap into single field
    // NOTE: This requires LlmDeserialize trait, not regular serde::Deserialize
    let response = r#"["a", "b", "c"]"#;
    let result: Result<ArrayWrapper, _> = parse(response);
    assert!(result.is_ok(), "Should coerce array into single field");
    let wrapper = result.unwrap();
    assert_eq!(wrapper.items, vec!["a", "b", "c"]);
}

#[test]
#[cfg(feature = "derive")]
fn test_implied_key_with_llm_deserialize() {
    use tryparse_derive::LlmDeserialize;

    #[derive(Debug, serde::Deserialize, LlmDeserialize, PartialEq)]
    struct Wrapper {
        data: String,
    }

    // Implied key inference WORKS - string is wrapped into single field
    let response = r#""hello world""#;
    let result: Wrapper = parse_llm(response).unwrap();
    assert_eq!(result.data, "hello world");
    assert_eq!(
        result,
        Wrapper {
            data: "hello world".to_string()
        }
    );

    // Also works with numbers
    #[derive(Debug, serde::Deserialize, LlmDeserialize)]
    struct NumWrapper {
        value: i64,
    }

    let response2 = "42";
    let result2: NumWrapper = parse_llm(response2).unwrap();
    assert_eq!(result2.value, 42);

    // Note: Transformation tracking for deserialization is a separate enhancement task
    // The feature works, but transformations from StructDeserializer aren't yet
    // propagated back to FlexValue candidates
}

#[test]
fn test_multi_field_struct_rejects_non_object() {
    #[derive(Deserialize, Debug)]
    #[allow(dead_code)] // Fields are deserialized but not directly accessed in test
    struct TwoFields {
        name: String,
        age: i64,
    }

    // Multi-field structs should NOT accept primitives
    let response = r#""hello""#;
    let result: Result<TwoFields, _> = parse(response);
    assert!(
        result.is_err(),
        "Multi-field struct should reject primitive"
    );
}

#[test]
#[ignore] // Implied key only works with LlmDeserialize, not serde::Deserialize
fn test_single_field_complex_value() {
    use serde_json::Value;

    #[derive(Deserialize, Debug)]
    struct JsonWrapper {
        content: Value,
    }

    // Complex object should wrap into single Value field
    // NOTE: This requires LlmDeserialize trait, not regular serde::Deserialize
    let response = r#"{"foo": "bar", "nested": {"num": 42}}"#;
    let result: Result<JsonWrapper, _> = parse(response);
    assert!(
        result.is_ok(),
        "Should wrap complex object into Value field"
    );
    let wrapper = result.unwrap();

    let obj = wrapper.content.as_object().unwrap();
    assert_eq!(obj.get("foo").unwrap(), "bar");
    assert_eq!(obj.get("nested").unwrap().get("num").unwrap(), 42);
}