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

use crate::TestError;
use std::convert::TryFrom;

#[derive(Debug, Clone)]
pub enum RelationField {
    ToOneOpt { child: bool },
    ToOneReq { child: bool },
    ToMany { child: bool },
}

impl RelationField {
    pub fn is_required(&self) -> bool {
        match self {
            RelationField::ToOneOpt { child: _ } => false,
            RelationField::ToOneReq { child: _ } => true,
            RelationField::ToMany { child: _ } => false,
        }
    }

    pub fn is_list(&self) -> bool {
        match self {
            RelationField::ToOneOpt { child: _ } => false,
            RelationField::ToOneReq { child: _ } => false,
            RelationField::ToMany { child: _ } => true,
        }
    }

    pub fn is_to_one_opt(&self) -> bool {
        matches!(self, Self::ToOneOpt { .. })
    }

    pub fn field_name(&self) -> String {
        match self {
            RelationField::ToOneOpt { child } => match child {
                true => "parentOpt",
                false => "childOpt",
            },
            RelationField::ToOneReq { child } => match child {
                true => "parentReq",
                false => "childReq",
            },
            RelationField::ToMany { child } => match child {
                true => "parentsOpt",
                false => "childrenOpt",
            },
        }
        .to_string()
    }

    pub fn type_name(&self) -> String {
        match self {
            RelationField::ToOneOpt { child } => match child {
                true => "Parent?",
                false => "Child?",
            },
            RelationField::ToOneReq { child } => match child {
                true => "Parent",
                false => "Child",
            },
            RelationField::ToMany { child } => match child {
                true => "Parent[]",
                false => "Child[]",
            },
        }
        .to_string()
    }

    pub fn optional_suffix(&self) -> String {
        match self {
            RelationField::ToOneOpt { child: _ } => "?",
            RelationField::ToOneReq { child: _ } => "",
            RelationField::ToMany { child: _ } => "",
        }
        .to_string()
    }
}

impl TryFrom<(&str, bool)> for RelationField {
    type Error = TestError;

    fn try_from(from: (&str, bool)) -> Result<Self, Self::Error> {
        let (name, child) = from;
        let rel_field = match name {
            "ToOneOpt" => RelationField::ToOneOpt { child },
            "ToOneReq" => RelationField::ToOneReq { child },
            "ToMany" => RelationField::ToMany { child },
            _ => {
                return Err(TestError::parse_error(format!(
                    "Unknown relation field `{name}`. Valid names are: ToOneOpt, ToOneReq and ToMany"
                )))
            }
        };

        Ok(rel_field)
    }
}