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
106
107
108
109
110
111
112
113

//! # Case
//!
//! This module contains primitives about case.
//! It provides an interface to compute the case of a given string.

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn case_recogniser() {
        use Case::*;
        assert_eq!(Case::compute("snakecase"), SnakeCase);
        assert_eq!(Case::compute("snake_case"), SnakeCase);
        assert_eq!(Case::compute("PascalCase"), PascalCase);
        assert_eq!(Case::compute("camelCase"), CamelCase);
        assert_eq!(Case::compute("Pascal_Snake_Case"), PascalSnakeCase);
        assert_eq!(Case::compute("UPPERCASE"), UpperCase);
        assert_eq!(Case::compute("SCREAMING_SNAKE_CASE"), ScreamingSnakeCase);
        assert_eq!(Case::compute(""), Other);
        assert_eq!(Case::compute("__"), Other);
        assert_eq!(Case::compute("fake snake case"), Other);
    }
}

/// # Summary
///
/// Indicate which type of case a certain string is written in.
#[derive(Debug, PartialEq, Eq)]
#[allow(clippy::enum_variant_names)]
pub enum Case {
    /// snakecase, snake_case
    SnakeCase,
    /// PascalCase
    PascalCase,
    /// camelCase,
    CamelCase,
    /// Pascal_Snake_Case,
    PascalSnakeCase,
    /// UPPERCASE
    UpperCase,
    /// SCREAMING_SNAKE_CASE,
    ScreamingSnakeCase,
    /// Not a known case
    Other,
}

impl Case {
    pub fn compute(string: &str) -> Self {
        if string.is_empty() {
            return Self::Other;
        }

        let mut contains_underscore = false;
        let mut first_is_capital = false;
        let mut contains_small = false;
        let mut contains_capital = false;

        let mut contains_non_alphanumeric = false;

        let mut first_alpha = true;

        for c in string.chars() {
            if c == '_' {
                contains_underscore = true;
            } else if c.is_ascii_uppercase() {
                contains_capital = true;
                if first_alpha {
                    first_is_capital = true;
                }
                first_alpha = false;
            } else if c.is_ascii_lowercase() {
                contains_small = true;
                first_alpha = false;
            } else {
                contains_non_alphanumeric = true;
            }
        }

        if first_alpha || contains_non_alphanumeric {
            Self::Other
        } else if !contains_capital {
            Self::SnakeCase
        } else if !first_is_capital {
            Self::CamelCase
        } else if contains_small {
            if contains_underscore {
                Self::PascalSnakeCase
            } else {
                Self::PascalCase
            }
        } else if contains_underscore {
            Self::ScreamingSnakeCase
        } else {
            Self::UpperCase
        }
    }
}

pub trait CaseProcess {
    fn case(&self) -> Case;
}

impl CaseProcess for &str {
    fn case(&self) -> Case {
        Case::compute(self)
    }
}

impl CaseProcess for String {
    fn case(&self) -> Case {
        Case::compute(self.as_str())
    }
}