cumulus 0.0.6

AWS CloudFormation Template Generator
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

use serde::Serialize;

use crate::skip_serializing_if::SkipSerializingIf;
use crate::Ref;

/// CloudFormation Template Parameter
/// See [AWS CloudFormation Documenation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html)
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Parameter {
    #[serde(skip)]
    name: String,
    #[serde(skip_serializing_if = "String::is_empty")]
    allowed_pattern: String,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    allowed_values: Vec<String>,
    #[serde(skip_serializing_if = "String::is_empty")]
    constraint_description: String,
    #[serde(skip_serializing_if = "String::is_empty")]
    default: String,
    #[serde(skip_serializing_if = "String::is_empty")]
    description: String,
    #[serde(skip_serializing_if = "u64::is_zero")]
    max_length: u64,
    #[serde(skip_serializing_if = "u64::is_zero")]
    max_value: u64,
    #[serde(skip_serializing_if = "u64::is_zero")]
    min_length: u64,
    #[serde(skip_serializing_if = "u64::is_zero")]
    min_value: u64,
    #[serde(skip_serializing_if = "bool::is_false")]
    no_echo: bool,
    r#type: DataType,
}

impl Parameter {
    /// Create new `Parameter` of `string` type
    pub fn string(name: impl Into<String>) -> Self {
        let name = name.into();
        let r#type = DataType::String;
        Self {
            name,
            r#type,
            ..<Self as Default>::default()
        }
    }

    /// Create new `Parameter` of `number` type
    pub fn number(name: impl Into<String>) -> Self {
        let name = name.into();
        let r#type = DataType::Number;
        Self {
            name,
            r#type,
            ..<Self as Default>::default()
        }
    }

    pub fn image_id(name: impl Into<String>) -> Self {
        let name = name.into();
        let r#type = DataType::AwsEc2ImageId;
        Self {
            name,
            r#type,
            ..<Self as Default>::default()
        }
    }

    /// Add parameter description
    pub fn description(self, description: impl Into<String>) -> Self {
        let description = description.into();
        Self {
            description,
            ..self
        }
    }

    /// Add parameter default value
    pub fn default(self, default: impl Into<String>) -> Self {
        let default = default.into();
        Self { default, ..self }
    }

    pub fn r#ref(&self) -> Ref {
        Ref::new(&self.name)
    }

    pub(crate) fn name(&self) -> String {
        self.name.clone()
    }
}

#[derive(Clone, Debug, Serialize)]
pub enum DataType {
    String,
    Number,
    #[serde(rename = "AWS::EC2::Image::Id")]
    AwsEc2ImageId,
}

impl Default for DataType {
    fn default() -> Self {
        Self::String
    }
}