ironic 1.0.9

A batteries-included, type-safe application framework for Rust
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

use convert_case::{Case, Casing};

use crate::CliError;

#[derive(Debug)]
pub(crate) struct Names {
    pub(crate) snake: String,
    pub(crate) pascal: String,
    pub(crate) kebab: String,
}

impl Names {
    pub(crate) fn parse(value: &str) -> Result<Self, CliError> {
        if !value.chars().any(char::is_alphabetic) {
            return Err(CliError::InvalidName {
                name: value.to_owned(),
            });
        }
        let safe_source = value
            .chars()
            .map(|character| {
                if character.is_alphanumeric() {
                    character
                } else {
                    ' '
                }
            })
            .collect::<String>();
        let snake = safe_source.to_case(Case::Snake);
        let pascal = safe_source.to_case(Case::Pascal);
        let kebab = safe_source.to_case(Case::Kebab);
        if snake.is_empty()
            || pascal.is_empty()
            || kebab.is_empty()
            || is_keyword(&snake)
            || snake.starts_with(|character: char| character.is_ascii_digit())
        {
            return Err(CliError::InvalidName {
                name: value.to_owned(),
            });
        }
        Ok(Self {
            snake,
            pascal,
            kebab,
        })
    }
}

fn is_keyword(value: &str) -> bool {
    matches!(
        value,
        "as" | "async"
            | "await"
            | "break"
            | "const"
            | "continue"
            | "crate"
            | "dyn"
            | "else"
            | "enum"
            | "extern"
            | "false"
            | "fn"
            | "for"
            | "if"
            | "impl"
            | "in"
            | "let"
            | "loop"
            | "match"
            | "mod"
            | "move"
            | "mut"
            | "pub"
            | "ref"
            | "return"
            | "self"
            | "static"
            | "struct"
            | "super"
            | "trait"
            | "true"
            | "type"
            | "unsafe"
            | "use"
            | "where"
            | "while"
    )
}