decasify 0.11.3

A CLI utility and library to cast strings to title-case according to locale specific style guides including Turkish support
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// SPDX-FileCopyrightText: © 2023 Caleb Maclennan <caleb@alerque.com>
// SPDX-License-Identifier: LGPL-3.0-only

#![doc = include_str!("../README.md")]
#![cfg_attr(docsrs, feature(doc_cfg))]

mod content;
mod generics;
mod traits;
pub mod types;

pub use content::Chunk;
#[cfg(feature = "unstable-trait")]
pub use traits::Decasify;
pub use types::{Case, Locale, StyleGuide, StyleOptions, StyleOptionsBuilder, Word};
pub use types::{Error, Result};

#[cfg(feature = "cli")]
#[doc(hidden)]
pub mod cli;

#[cfg(feature = "luamodule")]
#[doc(hidden)]
pub mod lua;

#[cfg(feature = "pythonmodule")]
#[doc(hidden)]
pub mod python;

#[cfg(feature = "wasm")]
#[doc(hidden)]
pub mod wasm;

mod en;
mod es;
mod tr;

/// Convert a string to a specific case following typesetting conventions for a target locale
pub fn case<TC, TL, TS, TO>(
    chunk: impl Into<Chunk>,
    case: TC,
    locale: TL,
    style: TS,
    opts: TO,
) -> Result<String>
where
    TC: TryInto<Case>,
    TL: TryInto<Locale>,
    TS: TryInto<StyleGuide>,
    TO: TryInto<StyleOptions>,
    Error: From<TC::Error>,
    Error: From<TL::Error>,
    Error: From<TS::Error>,
    Error: From<TO::Error>,
{
    let chunk: Chunk = chunk.into();
    let case: Case = case.try_into()?;
    let locale: Locale = locale.try_into()?;
    let style: StyleGuide = style.try_into()?;
    let opts: StyleOptions = opts.try_into()?;
    match case {
        Case::Lower => lowercase(chunk, locale),
        Case::Upper => uppercase(chunk, locale),
        Case::Sentence => sentencecase(chunk, locale),
        Case::Title => titlecase(chunk, locale, style, opts),
    }
}

/// Convert a string to title case following typesetting conventions for a target locale
pub fn titlecase<TL, TS, TO>(
    chunk: impl Into<Chunk>,
    locale: TL,
    style: TS,
    opts: TO,
) -> Result<String>
where
    TL: TryInto<Locale>,
    TS: TryInto<StyleGuide>,
    TO: TryInto<StyleOptions>,
    Error: From<TL::Error>,
    Error: From<TS::Error>,
    Error: From<TO::Error>,
{
    let chunk: Chunk = chunk.into();
    let locale: Locale = locale.try_into()?;
    let style: StyleGuide = style.try_into()?;
    let opts: StyleOptions = opts.try_into()?;
    Ok(match locale {
        Locale::EN => en::titlecase(chunk, style, opts),
        Locale::ES => es::titlecase(chunk, style, opts),
        Locale::TR => tr::titlecase(chunk, style, opts),
    })
}

/// Convert a string to lower case following typesetting conventions for a target locale
pub fn lowercase<TL>(chunk: impl Into<Chunk>, locale: TL) -> Result<String>
where
    TL: TryInto<Locale>,
    Error: From<TL::Error>,
{
    let chunk: Chunk = chunk.into();
    let locale: Locale = locale.try_into()?;
    Ok(match locale {
        Locale::EN => en::lowercase(chunk),
        Locale::ES => es::lowercase(chunk),
        Locale::TR => tr::lowercase(chunk),
    })
}

/// Convert a string to upper case following typesetting conventions for a target locale
pub fn uppercase<TL>(chunk: impl Into<Chunk>, locale: TL) -> Result<String>
where
    TL: TryInto<Locale>,
    Error: From<TL::Error>,
{
    let chunk: Chunk = chunk.into();
    let locale: Locale = locale.try_into()?;
    Ok(match locale {
        Locale::EN => en::uppercase(chunk),
        Locale::ES => es::uppercase(chunk),
        Locale::TR => tr::uppercase(chunk),
    })
}

/// Convert a string to sentence case following typesetting conventions for a target locale
pub fn sentencecase<TL>(chunk: impl Into<Chunk>, locale: TL) -> Result<String>
where
    TL: TryInto<Locale>,
    Error: From<TL::Error>,
{
    let chunk: Chunk = chunk.into();
    let locale: Locale = locale.try_into()?;
    Ok(match locale {
        Locale::EN => en::sentencecase(chunk),
        Locale::ES => es::sentencecase(chunk),
        Locale::TR => tr::sentencecase(chunk),
    })
}

fn get_override<F>(word: &Word, overrides: &Option<Vec<Word>>, case_fn: F) -> Option<Word>
where
    F: Fn(&String) -> String,
{
    let word_lower = case_fn(&word.word);
    overrides.as_ref().and_then(|words| {
        words
            .iter()
            .find(|w| case_fn(&w.word) == word_lower)
            .cloned()
    })
}