toql_derive 0.4.0

Library with derive for toql
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

#[derive(PartialEq, Eq, Clone, Debug)]
pub enum RenameCase {
    CamelCase,
    SnakeCase,
    ShoutySnakeCase,
    MixedCase,
}

impl RenameCase {
    pub const VARIANTS: [&'static str; 4] =
        ["CamelCase", "snake_case", "SHOUTY_SNAKE_CASE", "mixedCase"];

    pub fn rename_str(&self, s: &str) -> String {
        use heck::{CamelCase, MixedCase, ShoutySnakeCase, SnakeCase};

        match self {
            RenameCase::CamelCase => s.to_camel_case(),
            RenameCase::SnakeCase => s.to_snake_case(),
            RenameCase::ShoutySnakeCase => s.to_shouty_snake_case(),
            RenameCase::MixedCase => s.to_mixed_case(),
        }
    }
}

impl std::str::FromStr for RenameCase {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s {
            "CamelCase" => RenameCase::CamelCase,
            "snake_case" => RenameCase::SnakeCase,
            "SHOUTY_SNAKE_CASE" => RenameCase::ShoutySnakeCase,
            "mixedCase" => RenameCase::MixedCase,
            _ => return Err(()),
        })
    }
}

#[cfg(test)]
mod test {
    use super::RenameCase;

    #[test]
    fn camelcase() {
        assert_eq!(RenameCase::CamelCase.rename_str("ABC"), "Abc");
        assert_eq!(RenameCase::CamelCase.rename_str("abc_def"), "AbcDef");
    }
    #[test]
    fn snakecase() {
        assert_eq!(RenameCase::SnakeCase.rename_str("ABC"), "abc");
        assert_eq!(RenameCase::SnakeCase.rename_str("abc_def"), "abc_def");
    }
    #[test]
    fn shouty_snakecase() {
        assert_eq!(RenameCase::ShoutySnakeCase.rename_str("ABC"), "ABC");
        assert_eq!(RenameCase::ShoutySnakeCase.rename_str("abc_def"), "ABC_DEF");
    }
    #[test]
    fn mixedcase() {
        assert_eq!(RenameCase::MixedCase.rename_str("ABC"), "abc");
        assert_eq!(RenameCase::MixedCase.rename_str("abc_def"), "abcDef");
    }

    #[test]
    fn from_str() {
        use std::str::FromStr;
        assert_eq!(
            RenameCase::from_str("CamelCase").unwrap(),
            RenameCase::CamelCase
        );
        assert_eq!(
            RenameCase::from_str("snake_case").unwrap(),
            RenameCase::SnakeCase
        );
        assert_eq!(
            RenameCase::from_str("SHOUTY_SNAKE_CASE").unwrap(),
            RenameCase::ShoutySnakeCase
        );
        assert_eq!(
            RenameCase::from_str("mixedCase").unwrap(),
            RenameCase::MixedCase
        );
        assert!(RenameCase::from_str("unknown_case").is_err());
    }
}