iamgroot 0.3.0

Rust code generation from Open-RPC spec
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

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Primitive {
    String,
    Integer,
    Boolean,
    Null,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Rule {
    Regex(String),
    Min(i64),
    Max(i64),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Type {
    Unit,
    Primitive(Primitive, Vec<Rule>),
    Array(Box<Type>),
    Option(Box<Type>),
    Named(String),
}

#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub enum Visibility {
    #[default]
    Public,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Property {
    pub name: String,
    pub rename: String,
    pub r#type: Type,
    pub flatten: bool,
}

impl Property {
    pub fn of(r#type: Type) -> Self {
        Self {
            name: Default::default(),
            rename: Default::default(),
            r#type,
            flatten: false,
        }
    }
}

#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct Struct {
    pub name: String,
    pub properties: Vec<Property>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct Enum {
    pub name: String,
    pub variants: Vec<Variant>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Variant {
    Const { name: String, value: String },
    Struct(Struct),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Object {
    Struct(Struct),
    Enum(Enum),
    Type(Type),
    Alias(String, Type),
}

impl Object {
    pub fn with_name(self, name: String) -> Self {
        match self {
            Self::Struct(this) => Self::Struct(Struct { name, ..this }),
            Self::Enum(this) => Self::Enum(Enum { name, ..this }),
            Self::Type(ty) => Self::Alias(name, ty),
            Self::Alias(_, ty) => Self::Alias(name, ty),
        }
    }

    pub fn get_name(&self) -> &str {
        match self {
            Self::Struct(s) => &s.name,
            Self::Enum(e) => &e.name,
            Self::Type(_) => "",
            Self::Alias(name, _) => name,
        }
    }
}

#[derive(Debug, Clone)]
pub struct Method {
    pub doc: Option<String>,
    pub name: String,
    pub args: Vec<(String, Type)>,
    pub ret: Type,
}