raws-config 0.0.1

RAWS config component
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

use aws_config::{BehaviorVersion, ConfigLoader, SdkConfig};
use aws_types::app_name::AppName;
use aws_types::region::Region;

pub use output::Output;

mod output;

#[derive(Debug)]
pub struct Config {
    debug: bool,
    no_paginate: bool,
    output: Output,
    shared_config: SdkConfig,
}

impl Config {
    pub async fn new(
        debug: bool,
        no_paginate: bool,
        endpoint_url: Option<String>,
        profile: Option<String>,
        region: Option<String>,
        output: Option<Output>,
    ) -> Self {
        let output = output.unwrap_or_default();
        let app_name = AppName::new("raws").expect("valid app name");
        let shared_config = aws_config::defaults(BehaviorVersion::latest())
            .app_name(app_name)
            .optionally_profile(profile)
            .optionally_region(region)
            .optionally_endpoint_url(endpoint_url)
            .load()
            .await;

        Self {
            debug,
            no_paginate,
            output,
            shared_config,
        }
    }

    pub fn config(&self) -> &SdkConfig {
        &self.shared_config
    }

    pub fn no_paginate(&self) -> bool {
        self.no_paginate
    }

    pub fn show(&self, object: Box<dyn show::Show>) {
        let text = if self.debug {
            object.debug()
        } else {
            self.output.output(object)
        };
        fmtools::println!({ text });
    }
}

trait Optionally {
    fn optionally_profile(self, profile: Option<String>) -> Self;
    fn optionally_region(self, region: Option<String>) -> Self;
    fn optionally_endpoint_url(self, endpoint_url: Option<String>) -> Self;
}

impl Optionally for ConfigLoader {
    fn optionally_profile(self, profile: Option<String>) -> Self {
        if let Some(profile) = profile {
            self.profile_name(profile)
        } else {
            self
        }
    }

    fn optionally_region(self, region: Option<String>) -> Self {
        if let Some(region) = region.map(Region::new) {
            self.region(region)
        } else {
            self
        }
    }

    fn optionally_endpoint_url(self, endpoint_url: Option<String>) -> Self {
        if let Some(endpoint_url) = endpoint_url {
            self.endpoint_url(endpoint_url)
        } else {
            self
        }
    }
}