alef 0.25.37

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

use crate::e2e::escape::escape_gleam;

/// Render a single Gleam record-constructor call for one item of a
/// `json_object` list arg, driven by a `[crates.gleam.element_constructors]`
/// entry. Each field is dispatched by its `kind`:
///
/// * `file_path` - emits a Gleam string literal; relative paths are prefixed
///   with `test_documents_path` so they resolve from the e2e working dir.
/// * `byte_array` - emits a Gleam BitArray literal `<<n1, n2, ...>>` from a
///   JSON array of unsigned integers.
/// * `string` - emits a Gleam string literal; missing/null falls back to
///   the field's `default` (or `""`).
/// * `literal` - emits the field's `value` verbatim.
pub(super) fn render_gleam_element_constructor(
    item: &serde_json::Value,
    recipe: &crate::core::config::GleamElementConstructor,
    test_documents_path: &str,
) -> String {
    let mut field_exprs: Vec<String> = Vec::with_capacity(recipe.fields.len());
    for field in &recipe.fields {
        let expr = match field.kind.as_str() {
            "file_path" => {
                let json_field = field.json_field.as_deref().unwrap_or("");
                let path = item.get(json_field).and_then(|v| v.as_str()).unwrap_or("");
                let full = if path.starts_with('/') {
                    path.to_string()
                } else {
                    format!("{test_documents_path}/{path}")
                };
                format!("\"{}\"", escape_gleam(&full))
            }
            "byte_array" => {
                let json_field = field.json_field.as_deref().unwrap_or("");
                let bytes: Vec<String> = item
                    .get(json_field)
                    .and_then(|v| v.as_array())
                    .map(|arr| arr.iter().map(|b| b.as_u64().unwrap_or(0).to_string()).collect())
                    .unwrap_or_default();
                if bytes.is_empty() {
                    "<<>>".to_string()
                } else {
                    format!("<<{}>>", bytes.join(", "))
                }
            }
            "string" => {
                let json_field = field.json_field.as_deref().unwrap_or("");
                let value = item
                    .get(json_field)
                    .and_then(|v| v.as_str())
                    .map(str::to_string)
                    .or_else(|| field.default.clone())
                    .unwrap_or_default();
                format!("\"{}\"", escape_gleam(&value))
            }
            "literal" => field.value.clone().unwrap_or_default(),
            other => {
                // Unknown kind — fall back to a verbatim literal of the value
                // field if present, else an empty string. Surfacing the
                // unsupported kind in the generated code makes the error
                // visible at compile-time rather than failing silently.
                field
                    .value
                    .clone()
                    .unwrap_or_else(|| format!("\"<unsupported kind: {other}>\""))
            }
        };
        field_exprs.push(format!("{}: {}", field.gleam_field, expr));
    }
    format!("{}({})", recipe.constructor, field_exprs.join(", "))
}