caseidae 2.0.0

Convenient converters between letter casings of Rust identifiers.
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
118
119
120
121
122
123
124
125
126
127

use std::iter;

use convert_case::{Boundary, Case, Casing};
use convert_case_extras::is_case;

pub(crate) const RAW_IDENTIFIER_PREFIX: &str = "r#";
pub(crate) const LIFETIME_TICK_PREFIX: char = '\'';
pub(crate) const UNDERSCORE: char = '_';

pub(crate) const SNAKE_PASCAL_BOUNDARIES: [Boundary; 6] = [
    Boundary::DigitLower,
    Boundary::DigitUpper,
    Boundary::LowerDigit,
    Boundary::UpperDigit,
    Boundary::Custom {
        condition: |str| {
            str.first()
                .and_then(|str| str.chars().next())
                .is_some_and(|char| !char.is_ascii_alphanumeric())
        },
        start: 0,
        len: 1,
    },
    // Seperate by any uppercase, so that e.g. `ABC` is separated into three words.
    Boundary::Custom {
        condition: |str| {
            str.get(1)
                .and_then(|str| str.chars().next())
                .is_some_and(char::is_uppercase)
        },
        start: 1,
        len: 0,
    },
];

pub(crate) trait ConvertCasing {
    type Output;
    fn convert_casing(&self, casing: Case) -> Self::Output;
}

impl ConvertCasing for str {
    type Output = String;

    fn convert_casing(&self, casing: Case) -> Self::Output {
        // `self` can't be shadowed.
        let identifier = self;
        // Trim lifetime tick.
        let identifier = identifier
            .strip_prefix(LIFETIME_TICK_PREFIX)
            .unwrap_or(identifier);
        let (identifier, is_raw) = identifier
            .strip_prefix(RAW_IDENTIFIER_PREFIX)
            .map(|rest| (rest, true))
            .unwrap_or((identifier, false));
        let leading_underscore_count = identifier
            .chars()
            .take_while(|&char| char == UNDERSCORE)
            .count();
        let trailing_underscore_count = if leading_underscore_count < identifier.len() {
            identifier
                .chars()
                .rev()
                .take_while(|&char| char == UNDERSCORE)
                .count()
        } else {
            0
        };
        let identifier =
            &identifier[leading_underscore_count..identifier.len() - trailing_underscore_count];

        let boundaries = if is_case(identifier, Case::Constant) {
            Case::Constant.boundaries()
        } else {
            &SNAKE_PASCAL_BOUNDARIES
        };
        let converter = identifier.remove_empty().set_boundaries(boundaries);

        is_raw
            .then_some(RAW_IDENTIFIER_PREFIX.chars())
            .into_iter()
            .flatten()
            .chain(iter::repeat_n(UNDERSCORE, leading_underscore_count))
            .chain(converter.to_case(casing).chars())
            .chain(iter::repeat_n(UNDERSCORE, trailing_underscore_count))
            .collect()
    }
}

#[cfg(feature = "syn")]
use proc_macro2::Span;
#[cfg(feature = "syn")]
use syn::Ident;

#[cfg(feature = "syn")]
pub(crate) trait ConstructRawHandled {
    fn new_raw_handled(string: &str, span: Span) -> Self;
}

#[cfg(feature = "syn")]
impl ConstructRawHandled for Ident {
    fn new_raw_handled(string: &str, span: Span) -> Self {
        if string.is_raw_identifier() {
            Ident::new_raw(&string[2..], span)
        } else {
            Ident::new(string, span)
        }
    }
}

#[cfg(feature = "syn")]
pub(crate) trait IsRaw {
    fn is_raw_identifier(&self) -> bool;
}

#[cfg(feature = "syn")]
impl IsRaw for str {
    fn is_raw_identifier(&self) -> bool {
        self.starts_with(RAW_IDENTIFIER_PREFIX)
    }
}

#[cfg(feature = "syn")]
impl IsRaw for Ident {
    fn is_raw_identifier(&self) -> bool {
        self.to_string().is_raw_identifier()
    }
}