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

use crate::Result;
use std::fmt::Write;

pub const RESERVED_NAMES: &[&str] = &[
  "as",
  "use",
  "extern crate",
  "break",
  "const",
  "continue",
  "crate",
  "else",
  "if",
  "if let",
  "enum",
  "extern",
  "false",
  "fn",
  "for",
  "if",
  "impl",
  "in",
  "for",
  "let",
  "loop",
  "match",
  "mod",
  "move",
  "mut",
  "pub",
  "impl",
  "ref",
  "return",
  "Self",
  "self",
  "static",
  "struct",
  "super",
  "trait",
  "true",
  "type",
  "unsafe",
  "use",
  "where",
  "while",
  "abstract",
  "alignof",
  "become",
  "box",
  "do",
  "final",
  "macro",
  "offsetof",
  "override",
  "priv",
  "proc",
  "pure",
  "sizeof",
  "typeof",
  "unsized",
  "virtual",
  "yield",
  "dyn", "try", "async", "await", "union" ];


  pub fn format_doc(avro_doc: &Option<String>,spaces: &str) -> Result<String> {
    let mut field_doc= String::from("");
    if let Some(doc) = avro_doc{

        for line in doc.lines() {
            write!(field_doc,"{}/// {}\r\n",spaces,line)?;
        }
    }
    Ok(field_doc)
}

#[derive(Debug)]
pub struct SanitizedName {
    pub sanitized_name: String,
    pub original_name: String,
    pub is_sanitized: bool,
}

impl SanitizedName{
    pub fn from_field(original_name: &str) -> SanitizedName {
        Self::from(original_name, heck::ToSnekCase::to_snek_case,"field_")
    }

    pub fn from_module(original_name: &str) -> SanitizedName {
        Self::from(original_name, heck::ToSnekCase::to_snek_case,"module_")
    }

    pub fn from_type(original_name: &str) -> SanitizedName {
        Self::from(original_name, heck::ToUpperCamelCase::to_upper_camel_case,"Type")
    }

    fn from(original_name: &str,apply_fn:impl Fn(&str) ->String,reserved_name_prefix: &str) -> SanitizedName
    {
        let mut sanitized_name = apply_fn(original_name);

        if RESERVED_NAMES.iter().any(|s| *s == sanitized_name) {
            sanitized_name = format!("{}{}",reserved_name_prefix,sanitized_name);
        }
        
        let is_sanitized= sanitized_name != original_name;
        SanitizedName{
            sanitized_name,
            original_name: original_name.to_string(),
            is_sanitized}
    }
}