inflector-plus 0.11.7

Adds String based inflections for Rust. Snake, kebab, camel, word, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize are supported as both traits and pure functions acting on String types.
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

static VOWELS: [char; 5] = ['a', 'e', 'i', 'o', 'u'];

macro_rules! special_a_cases{
    ($s:ident, $($word: expr), *) => {
        $(
            if $s[..].starts_with($word) {
                let mut result = "a ".to_owned();
                result.push_str($s);
                return result;
            }
        )*
    }
}

macro_rules! special_an_cases{
    ($s:ident, $($word: expr), *) => {
        $(
            if $s[..].starts_with($word) {
                let mut result = "an ".to_owned();
                result.push_str($s);
                return result;
            }
        )*
    }
}

/// Converts a `&str` to articlized `String`
///
/// ```
///     use inflector::string::articlize::articlize;
///     let mock_string: &str = "egg";
///     let expected_string: String = "an egg".to_owned();
///     let asserted_string: String = articlize(mock_string);
///     assert!(asserted_string == expected_string);
///
/// ```
/// ```
///     use inflector::string::articlize::articlize;
///     let mock_string: &str = "user";
///     let expected_string: String = "a user".to_owned();
///     let asserted_string: String = articlize(mock_string);
///     assert!(asserted_string == expected_string);
///
/// ```
/// ```
///     use inflector::string::articlize::articlize;
///     let mock_string: &str = "hour";
///     let expected_string: String = "an hour".to_owned();
///     let asserted_string: String = articlize(mock_string);
///     assert!(asserted_string == expected_string);
///
/// ```
pub fn articlize(non_articlized_string: &str) -> String {
    special_a_cases![non_articlized_string,
        "euro",
        "user",
        "uni",
        "one",
        "use",
        "ut",
        "uranium",
        "urine",
        "unanimity",
        "euthanasia",
        "ewe",
        "ufo",
        "usu",
        "ub"
    ];
    special_an_cases![non_articlized_string,
        "hour",
        "hourly",
        "honor",
        "honest",
        "heiress",
        "xmas"
    ];
    if let Some(char) = non_articlized_string.chars().nth(0) {
        if VOWELS.contains(&char) {
            format!("an {non_articlized_string}")
        } else {
            format!("a {non_articlized_string}")
        }
    } else {
        non_articlized_string.to_owned()
    }
}

#[test]
fn articlize_strings_with_initial_lowercase_vowel() {
    assert_eq!("an apple", articlize("apple"));
    assert_eq!("an egg", articlize("egg"));
    assert_eq!("an oddball", articlize("oddball"));
}

#[test]
fn articlize_strings_with_initial_lowercase_consonant() {
    assert_eq!("a banana", articlize("banana"));
    assert_eq!("a holy", articlize("holy"));
    assert_eq!("a yellow", articlize("yellow"));
}

#[test]
fn articlize_strings_with_word_starts_with_word() {
    assert_eq!("a bananalike", articlize("bananalike"));
    assert_eq!("an hourly rate", articlize("hourly rate"));
}

#[test]
fn articlize_strings_special_case_user() {
    assert_eq!("a user", articlize("user"));
}

#[test]
fn articlize_strings_special_case_hour() {
    assert_eq!("an hour", articlize("hour"));
}