alef 0.115.5

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

use crate::e2e::field_access::FieldResolver;
use crate::e2e::fixture::Assertion;

pub(super) fn render(
    assertion: &Assertion,
    resolver: &FieldResolver,
    result: &str,
    android: bool,
    field: &str,
) -> Option<String> {
    let (prefix, owner, variant, suffix) = resolver.ir_tagged_union_split(field)?;
    if !resolver.union_variant_payload_is_collection(&owner, &variant) {
        return None;
    }
    if !android {
        return render_json(assertion, resolver, result, (&prefix, &owner, &variant, &suffix));
    }
    let (payload_name, element_type) = resolver.union_variant_payload(&owner, &variant)?;
    let style = if android { "kotlin_android" } else { "kotlin" };
    let container = if prefix.is_empty() {
        result.to_string()
    } else {
        resolver.accessor(&prefix, style, result)
    };
    let member = crate::backends::kotlin::kotlin_field_name_with_type(payload_name, 0, None, &variant, 1);
    let payload = format!("listVariant.{member}");
    let expression = if suffix.is_empty() {
        payload
    } else {
        indexed_leaf(resolver, element_type, &suffix, &payload, style)?
    };
    let expected = assertion.value.as_ref().map(super::super::values::json_to_kotlin)?;
    let kind = assertion.assertion_type.as_str();
    if !matches!(kind, "count_equals" | "equals" | "field_equals") {
        return None;
    }
    Some(crate::e2e::template_env::render(
        "kotlin/list_variant_assertion.jinja",
        crate::alef_context! { container => container, owner => owner, variant => variant,
        expression => expression, expected => expected, count => kind == "count_equals" },
    ))
}

/// The binding types that the typed (Android) rendering of `field` names: the union and the
/// union type of its list elements. The Android test package is a child of the binding package,
/// so it must import each of them. ~keep
pub(in crate::e2e::codegen::kotlin) fn android_imports(resolver: &FieldResolver, field: &str) -> Vec<String> {
    let Some((_, owner, variant, _)) = resolver.ir_tagged_union_split(field) else {
        return Vec::new();
    };
    let Some((_, element_type)) = resolver.union_variant_payload(&owner, &variant) else {
        return Vec::new();
    };
    if !resolver.union_variant_payload_is_collection(&owner, &variant) {
        return Vec::new();
    }
    let mut types = vec![owner];
    if resolver.enum_definition(element_type).is_some() {
        types.push(element_type.to_string());
    }
    types
}

fn indexed_leaf(resolver: &FieldResolver, owner: &str, suffix: &str, payload: &str, style: &str) -> Option<String> {
    let end = suffix.find(']')?;
    let element = resolver.element_accessor(&suffix[..=end], style, payload);
    let tail = suffix[end + 1..].trim_start_matches('.');
    if resolver.enum_definition(owner).is_none() {
        return Some(resolver.element_accessor(tail, style, &element));
    }
    let (head, remainder) = tail.split_once('.').unwrap_or((tail, ""));
    let metadata = resolver.enum_field_metadata(owner, head)?;
    let member = crate::backends::kotlin::kotlin_field_name_with_type(
        &metadata.field,
        0,
        metadata.next_type.as_deref(),
        &metadata.variant,
        1,
    );
    let narrowed = format!("({element} as {owner}.{}).{member}", metadata.variant);
    Some(if remainder.is_empty() {
        narrowed
    } else {
        resolver.element_accessor(remainder, style, &narrowed)
    })
}

fn render_json(
    assertion: &Assertion,
    resolver: &FieldResolver,
    result: &str,
    crossing: (&str, &str, &str, &str),
) -> Option<String> {
    let (prefix, owner, variant, suffix) = crossing;
    if !resolver.enum_definition(owner)?.serde_untagged {
        return None;
    }
    let container = if prefix.is_empty() {
        result.to_string()
    } else {
        resolver.accessor(prefix, "kotlin", result)
    };
    let payload = format!("kotlin.test.assertNotNull({container}).value()");
    let mut expression = payload.clone();
    for step in resolver.enum_payload_wire_steps(owner, variant, suffix)? {
        match step {
            crate::e2e::field_access::WireAccessStep::Field(key) => {
                let literal = super::super::values::json_to_kotlin(&serde_json::Value::String(key));
                expression.push_str(&format!(".get({literal})"));
            }
            crate::e2e::field_access::WireAccessStep::Index(index) => expression.push_str(&format!(".get({index})")),
        }
    }
    let kind = assertion.assertion_type.as_str();
    if !matches!(kind, "count_equals" | "equals" | "field_equals") {
        return None;
    }
    let expected_value = assertion.value.as_ref()?;
    if kind != "count_equals" && !expected_value.is_string() {
        return None;
    }
    Some(crate::e2e::template_env::render(
        "kotlin/list_variant_json_assertion.jinja",
        crate::alef_context! {
            payload => payload, expression => expression, expected => super::super::values::json_to_kotlin(expected_value),
            count => kind == "count_equals",
        },
    ))
}