caseconv 0.1.0

Case conversion library
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

use std::default::Default;
use super::*;
use super::case::*;

#[repr(C)]
#[derive(Clone)]
/// Runtime data type representing a case
pub enum CaseType {
    CAMEL,
    SNAKE,
    KEBAB
}

impl Default for CaseType {
    fn default() -> CaseType {
        CaseType::CAMEL
    }
}

const ALL_DEFINING_CASE_TYPES: [CaseType; 3] = [
    CaseType::CAMEL,
    CaseType::SNAKE,
    CaseType::KEBAB
];

impl CaseType {
    /// Attempts to guess the case of a given string by counting the # of
    /// components parsed for each case, and returning the one that finds the
    /// most.
    pub fn guess(s: &str) -> CaseType {
        let maybe_type = ALL_DEFINING_CASE_TYPES.iter()
            .map(|ty| (ty.clone(), ty.components_iter(s).count()))
            .max_by_key(|&(_, count)| count);
        match maybe_type {
            Some((ref ty, _)) => ty.clone(),
            None => Default::default(),
        }
    }
}

/// Runtime iterator for components of a string who's case is only known at
/// runtime.
pub enum CaseTypeIterator<'a> {
    Camel(CamelIterator<'a>),
    Delimeter(DelimeterIterator<'a>),
}

impl<'a> Iterator for CaseTypeIterator<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<&'a str> {
        match self {
            &mut CaseTypeIterator::Camel(ref mut it) => it.next(),
            &mut CaseTypeIterator::Delimeter(ref mut it) => it.next(),
        }
    }
}

impl<'a, 'b> DefiningCase<'a, CaseTypeIterator<'a>> for &'b CaseType {
    fn components_iter(self, src: &'a str) -> CaseTypeIterator<'a> {
        match *self {
            CaseType::CAMEL => CaseTypeIterator::Camel(CAMEL.components_iter(src)),
            CaseType::SNAKE => CaseTypeIterator::Delimeter(SNAKE.components_iter(src)),
            CaseType::KEBAB => CaseTypeIterator::Delimeter(KEBAB.components_iter(src)),
        }
    }
}

impl<'b> Case for &'b CaseType {
    fn build_identifier<'a, It: Iterator<Item=&'a str>>(self, components: It) -> String {
        match *self {
            CaseType::CAMEL => CAMEL.build_identifier(components),
            CaseType::SNAKE => SNAKE.build_identifier(components),
            CaseType::KEBAB => KEBAB.build_identifier(components),
        }
    }
}

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

    #[test]
    fn dynamic_camel_to_kebab() {
        let id = convert("simpleCamelCase", &CaseType::CAMEL, &CaseType::KEBAB);
        assert_eq!(id, "simple-camel-case");
    }
}