elastic-mapping-macro 0.1.0

Procedural macros for elastic-mapping - generate Elasticsearch mappings from Rust types
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

use crate::{
    DocumentVariant, MappingProperty,
    codegen::{IterableProperties, gen_object_mapping},
    error::GeneratorError,
    rename::RenameCasing,
};

/// Generates mapping for untagged enums (no tag attribute)
pub(crate) fn gen_untagged_enum(
    variants: &[DocumentVariant],
    rename_all: Option<RenameCasing>,
) -> Result<(Vec<MappingProperty>, Vec<IterableProperties>), GeneratorError> {
    let mut properties = Vec::new();
    let iterable = Vec::new();

    for variant in variants {
        let variant_name = variant.resolve_name(rename_all);
        let mut variant_properties = Vec::new();

        // Validate tuple variants
        if variant.fields.is_tuple() && variant.fields.len() != 1 {
            return Err(GeneratorError::Custom(
                "Tuple enums with multiple fields are not supported".to_string(),
            ));
        }

        match variant.fields.style {
            darling::ast::Style::Tuple => {
                let field = &variant.fields.fields[0];
                let ty = &field.ty;

                variant_properties.push(quote::quote! {
                    let mut prop = <#ty as elastic_mapping::MappingType>::fields();
                });
            }
            darling::ast::Style::Struct => {
                for field in variant.fields.iter() {
                    // Serde does not apply rename_all to struct variants
                    let field_mapping = field.gen_mapping(None);
                    let field_name = field_mapping.name;
                    let field_code = field_mapping.mapping;

                    variant_properties.push(quote::quote! {
                        prop.insert(#field_name.into(), #field_code)
                    });
                }
            }
            darling::ast::Style::Unit => {
                return Err(GeneratorError::Custom(
                    "Unit variants are not supported in untagged enums".to_string(),
                ));
            }
        }

        let mapping = gen_object_mapping(variant_properties);
        properties.push(MappingProperty {
            name: variant_name,
            mapping,
        });
    }

    Ok((properties, iterable))
}