avrogen 0.3.4

This program allow allow to generate rust code from avro definition files. Modules are created from namespace information
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

use crate::Result;
use apache_avro::schema::*;
use std::fmt::Write;

use super::{field_default_value::FieldDefault, field_type::*, global::*};

#[derive(Debug)]
pub struct GeneratedStructFields {
    parent_struct_fullname: String,

    name: SanitizedName,

    doc: String,

    type_name: String,

    serde_with_line: Option<&'static str>,

    default: Option<FieldDefault>,
}

impl GeneratedStructFields {
    pub fn has_default(&self) -> bool {
        self.default.is_some()
    }

    pub fn from(
        field: &RecordField,
        structure_name: &SanitizedName,
        default_namespace: &Option<String>,
    ) -> Result<Self> {
        let field_name = SanitizedName::from_field(&field.name);
        let field_type = get_field_type(&field.schema, default_namespace)?;

        let doc = format_doc(&field.doc, "    ")?;
        let serde_with_line = get_serde_with(field)?;

        let default = match &field.default {
            None => None,
            Some(val) => Some(FieldDefault::from(val, &field.schema)?),
        };

        Ok(GeneratedStructFields {
            name: field_name,
            parent_struct_fullname: structure_name.sanitized_name.to_owned(),
            type_name: field_type,
            serde_with_line,
            doc,
            default,
        })
    }

    pub fn write_struct_declaration_content(&self) -> Result<String> {
        let mut content = self.doc.to_owned();

        if let Some(line) = &self.serde_with_line {
            writeln!(content, "    {line}")?;
        };
        if self.name.is_sanitized {
            writeln!(
                content,
                "    #[serde(rename = \"{}\")]",
                self.name.original_name
            )?
        }
        if self.default.is_some() {
            writeln!(
                content,
                "    #[serde(default = \"{}::default_{}\")]",
                self.parent_struct_fullname, self.name.sanitized_name
            )?;
        }
        writeln!(
            content,
            "    pub {}: {},",
            self.name.sanitized_name, self.type_name
        )?;

        Ok(content)
    }

    pub fn write_struct_default_method_content(&self) -> Result<Option<String>> {
        match &self.default {
            Some(default) => {
                let default_value_str = default
                    .write_content()
                    .map_err(|e| format!("{} => {e}", self.name.sanitized_name))?;

                Ok(format!(
                    "\r\n    #[inline(always)]\r\n    pub fn default_{}() -> {} {{\r\n        {}\r\n    }}\r\n",
                    self.name.sanitized_name, self.type_name, default_value_str
                )
                .into())
            }
            None => Ok(None),
        }
    }
}

fn get_serde_with(field: &RecordField) -> Result<Option<&'static str>> {
    Ok(match field.schema {
        Schema::Date => None,
        Schema::TimeMillis => Some("#[serde(with = \"chrono::naive::serde::ts_milliseconds\")]"),
        Schema::TimeMicros => Some("#[serde(with = \"chrono::naive::serde::ts_microseconds\")]"),
        Schema::TimestampMillis => {
            Some("#[serde(with = \"chrono::naive::serde::ts_milliseconds\")]")
        }
        Schema::TimestampMicros => {
            Some("#[serde(with = \"chrono::naive::serde::ts_microseconds\")]")
        }
        Schema::LocalTimestampMillis => {
            Some("#[serde(with = \"chrono::naive::serde::ts_milliseconds\")]")
        }
        Schema::LocalTimestampMicros => {
            Some("#[serde(with = \"chrono::naive::serde::ts_microseconds\")]")
        }
        _ => None,
    })
}