alef 0.75.0

Opinionated polyglot binding generator for Rust libraries
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

use crate::codegen::conversions::*;
use crate::core::ir::*;
use ahash::AHashSet;

// Regression coverage for task #405: a `Vec` field element that fails to (de)serialize must
// not silently vanish from the collected `Vec` (via `.filter_map(...).ok())`) — that shrinks
// the element count and shifts every later element's index, which is worse than a wrong value
// because it is undetectable from the output shape alone. Every one of these conversions runs
// inside an infallible `fn from(val) -> Self`, so `?`-propagation cannot be used here; the fix
// keeps the count aligned with the source by substituting a default (or `Value::Null`) for the
// element that failed, instead of dropping it.

#[test]
fn vec_json_binding_to_core_preserves_count_on_parse_failure_non_optional() {
    let result = field_conversion_to_core("payloads", &TypeRef::Vec(Box::new(TypeRef::Json)), false);
    assert_eq!(
        result,
        "payloads: val.payloads.into_iter().map(|s| serde_json::from_str(&s).unwrap_or_default()).collect()"
    );
}

#[test]
fn vec_json_binding_to_core_preserves_count_on_parse_failure_optional() {
    let result = field_conversion_to_core("payloads", &TypeRef::Vec(Box::new(TypeRef::Json)), true);
    assert_eq!(
        result,
        "payloads: val.payloads.map(|v| v.into_iter().map(|s| serde_json::from_str(&s).unwrap_or_default()).collect())"
    );
}

#[test]
fn map_of_vec_json_binding_to_core_preserves_count_on_parse_failure() {
    let result = field_conversion_to_core(
        "grouped",
        &TypeRef::Map(
            Box::new(TypeRef::String),
            Box::new(TypeRef::Vec(Box::new(TypeRef::Json))),
        ),
        false,
    );
    assert_eq!(
        result,
        "grouped: val.grouped.into_iter().map(|(k, v)| (k.into(), v.into_iter().map(|s| serde_json::from_str(&s).unwrap_or_default()).collect())).collect()"
    );
}

#[test]
fn vec_untagged_enum_binding_to_core_preserves_count_on_deserialize_failure() {
    let mut untagged = AHashSet::new();
    untagged.insert("Shape".to_string());
    let config = ConversionConfig {
        untagged_data_enum_names: Some(&untagged),
        ..ConversionConfig::default()
    };

    let result = field_conversion_to_core_cfg(
        "shapes",
        &TypeRef::Vec(Box::new(TypeRef::Named("Shape".into()))),
        false,
        &config,
    );

    assert_eq!(
        result,
        "shapes: val.shapes.into_iter().map(|x| serde_json::from_value(x).unwrap_or_default()).collect()"
    );
}

#[test]
fn optional_vec_untagged_enum_binding_to_core_preserves_count_on_deserialize_failure() {
    let mut untagged = AHashSet::new();
    untagged.insert("Shape".to_string());
    let config = ConversionConfig {
        untagged_data_enum_names: Some(&untagged),
        ..ConversionConfig::default()
    };

    let result = field_conversion_to_core_cfg(
        "shapes",
        &TypeRef::Optional(Box::new(TypeRef::Vec(Box::new(TypeRef::Named("Shape".into()))))),
        false,
        &config,
    );

    assert_eq!(
        result,
        "shapes: val.shapes.map(|v| v.into_iter().map(|x| serde_json::from_value(x).unwrap_or_default()).collect())"
    );
}

#[test]
fn vec_untagged_enum_core_to_binding_preserves_count_on_serialize_failure() {
    let mut untagged = AHashSet::new();
    untagged.insert("Shape".to_string());
    let config = ConversionConfig {
        untagged_data_enum_names: Some(&untagged),
        ..ConversionConfig::default()
    };
    let opaque_types = AHashSet::new();

    let result = field_conversion_from_core_cfg(
        "shapes",
        &TypeRef::Vec(Box::new(TypeRef::Named("Shape".into()))),
        false,
        false,
        &opaque_types,
        &config,
    );

    assert_eq!(
        result,
        "shapes: val.shapes.iter().map(|x| serde_json::to_value(x).unwrap_or(serde_json::Value::Null)).collect()"
    );
}

#[test]
fn optional_vec_untagged_enum_core_to_binding_preserves_count_on_serialize_failure() {
    let mut untagged = AHashSet::new();
    untagged.insert("Shape".to_string());
    let config = ConversionConfig {
        untagged_data_enum_names: Some(&untagged),
        ..ConversionConfig::default()
    };
    let opaque_types = AHashSet::new();

    let result = field_conversion_from_core_cfg(
        "shapes",
        &TypeRef::Optional(Box::new(TypeRef::Vec(Box::new(TypeRef::Named("Shape".into()))))),
        false,
        false,
        &opaque_types,
        &config,
    );

    assert_eq!(
        result,
        "shapes: val.shapes.as_ref().map(|v| v.iter().map(|x| serde_json::to_value(x).unwrap_or(serde_json::Value::Null)).collect())"
    );
}