keyflux 0.1.15

A CLI tool and library for synchronizing environment secrets across multiple platforms including local files, GitHub Secrets, Supabase Vault, and Vercel Secrets. It facilitates secure management and automation of sensitive data.
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

use std::env;
use std::fs;
use std::fs::File;
use std::io::Write;
use std::path::Path;



// let out_dir = env::var("OUT_DIR").expect("OUT_DIR not defined");

// Make sure to bring the app definition into scope. This might require
// the app to be defined in a lib.rs instead of main.rs to be accessible here.
// let mut app = my_cli_app::Cli::command(); // Adjust this to match how you can access your CLI


fn generate_file<P: AsRef<Path>>(path: P, text: &[u8]) {
    let mut f = File::create(path).unwrap();
    f.write_all(text).unwrap()
}

fn main() {
    let out_dir = env::var("OUT_DIR").unwrap();
    let dest_path = Path::new(&out_dir).join("locales.rs");

    let mut locales = Vec::new();
    let i18n_path = Path::new("i18n");

    if let Ok(entries) = fs::read_dir(i18n_path) {
        for entry in entries {
            if let Ok(entry) = entry {
                if let Some(ext) = entry.path().extension() {
                    if ext == "yaml" || ext == "yml" {
                        if let Some(stem) = entry.path().file_stem() {
                            if let Some(stem_str) = stem.to_str() {
                                locales.push(stem_str.to_string());
                            }
                        }
                    }
                }
            }
        }
    }

    let locale_enum = locales.iter().map(|locale| {
        format!("    {},", locale.to_uppercase())
    }).collect::<Vec<_>>().join("\n");

    let locale_impl = locales.iter().map(|locale| {
        format!("            \"{}\" => Ok(Locale::{}),", locale, locale.to_uppercase())
    }).collect::<Vec<_>>().join("\n");

    let locale_display_impl = locales.iter().map(|locale| {
        format!("            Locale::{} => \"{}\",", locale.to_uppercase(), locale)
    }).collect::<Vec<_>>().join("\n");

    let supported_locales = locales.iter().map(|locale| {
        format!("Locale::{}", locale.to_uppercase())
    }).collect::<Vec<_>>().join(", ");

    let locale_code = format!(r#"
#[derive(Debug, Clone, clap::ValueEnum)]
pub enum Locale {{
{locale_enum}
}}

impl std::str::FromStr for Locale {{
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {{
        match s.to_lowercase().as_str() {{
{locale_impl}
            _ => Err(format!("'{{}}' is not a valid locale", s)),
        }}
    }}
}}

impl ToString for Locale {{
    fn to_string(&self) -> String {{
        match self {{
{locale_display_impl}
        }}.to_string()
    }}
}}

impl Into<&'static str> for Locale {{
    fn into(self) -> &'static str {{
        match self {{
{locale_display_impl}
        }}
    }}
}}

pub const SUPPORTED_LOCALES: &[Locale] = &[{supported_locales}];
"#, locale_enum = locale_enum, locale_impl = locale_impl, locale_display_impl = locale_display_impl, supported_locales = supported_locales);

    // fs::write(dest_path, locale_code).unwrap();
    generate_file(dest_path, locale_code.as_bytes());
}