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

pub(crate) fn generate(
    mut writer: impl std::io::Write,
    type_name: &str,
    generics: super::Generics<'_>,
    fields: &[super::Property<'_>],
    map_namespace: &impl crate::MapNamespace,
) -> Result<(), crate::Error> {
    let local = crate::map_namespace_local_to_string(map_namespace)?;

    let type_generics_type = generics.type_part.map(|part| format!("<{part}>")).unwrap_or_default();
    let type_generics_where = generics.where_part.map(|part| format!(" where {part}")).unwrap_or_default();

    let mut merge_body = String::new();
    for super::Property { field_name, merge_type, .. } in fields {
        generate_field(
            &mut merge_body,
            &local,
            &format!("&mut self.{field_name}"),
            &format!("other.{field_name}"),
            merge_type,
            8,
        )?;
    }

    writeln!(
        writer,
        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/struct_deep_merge.rs")),
        local = local,
        type_name = type_name,
        type_generics_type = type_generics_type,
        type_generics_where = type_generics_where,
        merge_body = merge_body,
    )?;

    Ok(())
}

fn generate_field(
    writer: &mut impl std::fmt::Write,
    local: &str,
    self_name: &str,
    other_name: &str,
    merge_type: &crate::swagger20::MergeType,
    indent: usize,
) -> Result<(), crate::Error> {
    const S: &str = "";

    match merge_type {
        crate::swagger20::MergeType::Default => writeln!(
            writer,
            "{S:indent$}{local}DeepMerge::merge_from({self_name}, {other_name});",
        )?,

        crate::swagger20::MergeType::List {
            strategy: crate::swagger20::KubernetesListType::Atomic,
            keys: _,
            item_merge_type: _,
        } => writeln!(
            writer,
            "{S:indent$}{local}merge_strategies::list::atomic({self_name}, {other_name});",
        )?,

        crate::swagger20::MergeType::List {
            strategy: crate::swagger20::KubernetesListType::Map,
            keys,
            item_merge_type,
        } => {
            writeln!(writer, "{S:indent$}{local}merge_strategies::list::map(")?;
            writeln!(writer, "{S:indent$}    {self_name},")?;
            writeln!(writer, "{S:indent$}    {other_name},")?;
            writeln!(
                writer,
                "{S:indent$}    &[{keys}],",
                keys = keys.iter().map(|k| format!("|lhs, rhs| lhs.{k} == rhs.{k}", k = crate::get_rust_ident(k))).collect::<Vec<_>>().join(", "),
            )?;
            writeln!(writer, "{S:indent$}    |current_item, other_item| {{")?;
            generate_field(writer, local, "current_item", "other_item", item_merge_type, indent + 8)?;
            writeln!(writer, "{S:indent$}    }},")?;
            writeln!(writer, "{S:indent$});")?;
        },

        crate::swagger20::MergeType::List {
            strategy: crate::swagger20::KubernetesListType::Set,
            keys: _,
            item_merge_type: _,
        } => writeln!(
            writer,
            "{S:indent$}{local}merge_strategies::list::set({self_name}, {other_name});",
        )?,

        crate::swagger20::MergeType::Map {
            strategy: crate::swagger20::KubernetesMapType::Granular,
            value_merge_type,
        } => {
            writeln!(
                writer,
                "{S:indent$}{local}merge_strategies::map::granular({self_name}, {other_name}, |current_item, other_item| {{",
            )?;
            generate_field(writer, local, "current_item", "other_item", value_merge_type, indent + 4)?;
            writeln!(writer, "{S:indent$}}});")?;
        },

        crate::swagger20::MergeType::Map {
            strategy: crate::swagger20::KubernetesMapType::Atomic,
            value_merge_type: _,
        } => writeln!(
            writer,
            "{S:indent$}{local}merge_strategies::map::atomic({self_name}, {other_name});",
        )?,
    }

    Ok(())
}