decasify 0.6.1__tar.gz → 0.7.1__tar.gz

{decasify-0.6.1 → decasify-0.7.1}/Cargo.lock

@@ -271,7 +271,7 @@ dependencies = [
 
 [[package]]
 name = "decasify"
-version = "0.6.1"
+version = "0.7.1"
 dependencies = [
  "assert_cmd",
  "clap",

{decasify-0.6.1 → decasify-0.7.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "decasify"
-version = "0.6.1"
+version = "0.7.1"
 authors = ["Caleb Maclennan <caleb@alerque.com>"]
 edition = "2021"
 rust-version = "1.73.0"

{decasify-0.6.1 → decasify-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: decasify
-Version: 0.6.1
+Version: 0.7.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
@@ -123,21 +123,21 @@ In your `Cargo.toml` file.
 
 ```toml
 [dependencies]
-decasify = "0.6"
+decasify = "0.7"
 ```
 
 Then use the crate functions and types in your project something like this:
 
 ```rust
 use decasify::to_titlecase;
-use decasify::{InputLocale, StyleGuide};
+use decasify::{Locale, StyleGuide};
 
 fn demo() {
     let input = "ILIK SU VE İTEN RÜZGARLAR";
-    let output = to_titlecase(input, InputLocale::TR, None);
+    let output = to_titlecase(input, Locale::TR, StyleGuide::LanguageDefault);
     eprintln! {"{output}"};
     let input = "title with a twist: a colon";
-    let output = to_titlecase(input, InputLocale::EN, Some(StyleGuide::DaringFireball));
+    let output = to_titlecase(input, Locale::EN, StyleGuide::DaringFireball);
     eprintln! {"{output}"};
 }
 ```
@@ -181,10 +181,10 @@ Then import and use the provided functions and type classes:
 from decasify import *
 
 input = "ILIK SU VE İTEN RÜZGARLAR"
-output = titlecase(input, InputLocale.TR)
+output = titlecase(input, Locale.TR)
 print(output)
 input = "title with a twist: a colon"
-output  = titlecase(input, InputLocale.EN, StyleGuide.DaringFireball)
+output  = titlecase(input, Locale.EN, StyleGuide.DaringFireball)
 print(output)
 ```
 
@@ -195,14 +195,14 @@ Depend on the WASM based JavaScript module in your project with `npm add decasif
 Then import and use the provided functions and classes:
 
 ```javascript
-import { titlecase, uppercase, lowercase, InputLocale, StyleGuide } from 'decasify';
+import { titlecase, uppercase, lowercase, Locale, StyleGuide } from 'decasify';
 
 var input = "ILIK SU VE İTEN RÜZGARLAR"
-var output = titlecase(input, InputLocale.TR)
+var output = titlecase(input, Locale.TR)
 console.log(output)
 
 var input = "title with a twist: a colon"
-var output = titlecase(input, InputLocale.EN, StyleGuide.DaringFireball)
+var output = titlecase(input, Locale.EN, StyleGuide.DaringFireball)
 console.log(output)
 ```
 

{decasify-0.6.1 → decasify-0.7.1}/README.md

@@ -101,21 +101,21 @@ In your `Cargo.toml` file.
 
 ```toml
 [dependencies]
-decasify = "0.6"
+decasify = "0.7"
 ```
 
 Then use the crate functions and types in your project something like this:
 
 ```rust
 use decasify::to_titlecase;
-use decasify::{InputLocale, StyleGuide};
+use decasify::{Locale, StyleGuide};
 
 fn demo() {
     let input = "ILIK SU VE İTEN RÜZGARLAR";
-    let output = to_titlecase(input, InputLocale::TR, None);
+    let output = to_titlecase(input, Locale::TR, StyleGuide::LanguageDefault);
     eprintln! {"{output}"};
     let input = "title with a twist: a colon";
-    let output = to_titlecase(input, InputLocale::EN, Some(StyleGuide::DaringFireball));
+    let output = to_titlecase(input, Locale::EN, StyleGuide::DaringFireball);
     eprintln! {"{output}"};
 }
 ```
@@ -159,10 +159,10 @@ Then import and use the provided functions and type classes:
 from decasify import *
 
 input = "ILIK SU VE İTEN RÜZGARLAR"
-output = titlecase(input, InputLocale.TR)
+output = titlecase(input, Locale.TR)
 print(output)
 input = "title with a twist: a colon"
-output  = titlecase(input, InputLocale.EN, StyleGuide.DaringFireball)
+output  = titlecase(input, Locale.EN, StyleGuide.DaringFireball)
 print(output)
 ```
 
@@ -173,14 +173,14 @@ Depend on the WASM based JavaScript module in your project with `npm add decasif
 Then import and use the provided functions and classes:
 
 ```javascript
-import { titlecase, uppercase, lowercase, InputLocale, StyleGuide } from 'decasify';
+import { titlecase, uppercase, lowercase, Locale, StyleGuide } from 'decasify';
 
 var input = "ILIK SU VE İTEN RÜZGARLAR"
-var output = titlecase(input, InputLocale.TR)
+var output = titlecase(input, Locale.TR)
 console.log(output)
 
 var input = "title with a twist: a colon"
-var output = titlecase(input, InputLocale.EN, StyleGuide.DaringFireball)
+var output = titlecase(input, Locale.EN, StyleGuide.DaringFireball)
 console.log(output)
 ```
 

{decasify-0.6.1 → decasify-0.7.1}/src/bin/decasify.rs

@@ -3,7 +3,7 @@
 
 use decasify::cli::Cli;
 use decasify::{to_lowercase, to_sentencecase, to_titlecase, to_uppercase};
-use decasify::{InputLocale, Result, StyleGuide, TargetCase};
+use decasify::{Case, Locale, Result, StyleGuide};
 
 use clap::CommandFactory;
 use std::io;
@@ -13,9 +13,9 @@ fn main() -> Result<()> {
     let version = option_env!("VERGEN_GIT_DESCRIBE").unwrap_or_else(|| env!("CARGO_PKG_VERSION"));
     let app = Cli::command().version(version);
     let matches = app.get_matches();
-    let locale = matches.get_one::<InputLocale>("locale").unwrap();
-    let case = matches.get_one::<TargetCase>("case").unwrap().to_owned();
-    let style = matches.get_one::<StyleGuide>("style").map(|s| s.to_owned());
+    let locale = matches.get_one::<Locale>("locale").unwrap();
+    let case = matches.get_one::<Case>("case").unwrap().to_owned();
+    let style = matches.get_one::<StyleGuide>("style").unwrap().to_owned();
     match matches.contains_id("input") {
         true => {
             let input: Vec<String> = matches
@@ -38,16 +38,17 @@ fn main() -> Result<()> {
 
 fn process<I: IntoIterator<Item = String>>(
     strings: I,
-    locale: InputLocale,
-    case: TargetCase,
-    style: Option<StyleGuide>,
+    locale: Locale,
+    case: Case,
+    style: StyleGuide,
 ) {
     for string in strings {
         let output = match case {
-            TargetCase::Title => to_titlecase(string, locale, style),
-            TargetCase::Lower => to_lowercase(string, locale),
-            TargetCase::Upper => to_uppercase(string, locale),
-            TargetCase::Sentence => to_sentencecase(string, locale),
+            Case::Title => to_titlecase(string, locale, style),
+            Case::Lower => to_lowercase(string, locale),
+            Case::Upper => to_uppercase(string, locale),
+            Case::Sentence => to_sentencecase(string, locale),
+            _ => unreachable!(),
         };
         println!("{output}")
     }

{decasify-0.6.1 → decasify-0.7.1}/src/cli.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 #[cfg(build)]
-use crate::{InputLocale, StyleGuide, TargetCase};
+use crate::{Case, Locale, StyleGuide};
 
 use clap::{builder, Parser};
 use strum::VariantNames;
@@ -21,16 +21,16 @@ macro_rules! clap_enum_variants {
 #[clap(author, bin_name = "decasify")]
 pub struct Cli {
     /// Locale
-    #[clap(short, long, default_value_t, ignore_case = true, value_parser = clap_enum_variants!(InputLocale))]
-    pub locale: InputLocale,
+    #[clap(short, long, default_value_t, ignore_case = true, value_parser = clap_enum_variants!(Locale))]
+    pub locale: Locale,
 
     /// Target case
-    #[clap(short, long, default_value_t, ignore_case = true, value_parser = clap_enum_variants!(TargetCase))]
-    pub case: TargetCase,
+    #[clap(short, long, default_value_t, ignore_case = true, value_parser = clap_enum_variants!(Case))]
+    pub case: Case,
 
     /// Style Guide
-    #[clap(short, long, ignore_case = true, value_parser = clap_enum_variants!(StyleGuide))]
-    pub style: Option<StyleGuide>,
+    #[clap(short, long, default_value_t, ignore_case = true, value_parser = clap_enum_variants!(StyleGuide))]
+    pub style: StyleGuide,
 
     /// Input string
     pub input: Vec<String>,

{decasify-0.6.1 → decasify-0.7.1}/src/content.rs

@@ -6,20 +6,22 @@ use regex::Regex;
 use std::{borrow::Cow, error, fmt, fmt::Display, str::FromStr};
 
 #[derive(Clone, Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Segment {
     Separator(String),
     Word(String),
 }
 
 #[derive(Debug, Clone)]
+#[non_exhaustive]
 pub struct Chunk {
     pub segments: Vec<Segment>,
 }
 
-fn split_chunk(src: &str) -> Chunk {
+fn split_chunk(s: &str) -> Chunk {
     let mut segments: Vec<Segment> = Vec::new();
     let captures = Regex::new(r"(?<separator>\p{Whitespace}+)|(?<word>\P{Whitespace}+)").unwrap();
-    for capture in captures.captures_iter(src) {
+    for capture in captures.captures_iter(s) {
         if let Some(m) = capture.name("separator") {
             segments.push(Segment::Separator(m.as_str().to_string()));
         } else if let Some(m) = capture.name("word") {
@@ -30,33 +32,33 @@ fn split_chunk(src: &str) -> Chunk {
 }
 
 impl From<String> for Chunk {
-    fn from(src: String) -> Self {
-        split_chunk(src.as_ref())
+    fn from(s: String) -> Self {
+        split_chunk(s.as_ref())
     }
 }
 
 impl From<&String> for Chunk {
-    fn from(src: &String) -> Self {
-        split_chunk(src.as_ref())
+    fn from(s: &String) -> Self {
+        split_chunk(s.as_ref())
     }
 }
 
 impl From<&str> for Chunk {
-    fn from(src: &str) -> Self {
-        split_chunk(src)
+    fn from(s: &str) -> Self {
+        split_chunk(s)
     }
 }
 
 impl From<&Cow<'_, str>> for Chunk {
-    fn from(src: &Cow<'_, str>) -> Self {
-        split_chunk(src)
+    fn from(s: &Cow<'_, str>) -> Self {
+        split_chunk(s)
     }
 }
 
 impl FromStr for Chunk {
     type Err = Box<dyn error::Error>;
-    fn from_str(src: &str) -> Result<Self> {
-        Ok(split_chunk(src))
+    fn from_str(s: &str) -> Result<Self> {
+        Ok(split_chunk(s))
     }
 }
 

{decasify-0.6.1 → decasify-0.7.1}/src/lib.rs

@@ -12,7 +12,7 @@ pub mod content;
 pub mod types;
 
 pub use content::{Chunk, Segment};
-pub use types::{InputLocale, Result, StyleGuide, TargetCase};
+pub use types::{Case, Locale, Result, StyleGuide};
 
 #[cfg(feature = "cli")]
 pub mod cli;
@@ -26,55 +26,76 @@ pub mod python;
 #[cfg(feature = "wasm")]
 pub mod wasm;
 
+/// Convert a string to a specific case following typesetting conventions for a target locale
+pub fn to_case(
+    chunk: impl Into<Chunk>,
+    case: impl Into<Case>,
+    locale: impl Into<Locale>,
+    style: impl Into<StyleGuide>,
+) -> String {
+    let chunk: Chunk = chunk.into();
+    let case: Case = case.into();
+    let locale: Locale = locale.into();
+    let style: StyleGuide = style.into();
+    match case {
+        Case::Lower => to_lowercase(chunk, locale),
+        Case::Upper => to_uppercase(chunk, locale),
+        Case::Sentence => to_sentencecase(chunk, locale),
+        Case::Title => to_titlecase(chunk, locale, style),
+    }
+}
+
 /// Convert a string to title case following typesetting conventions for a target locale
 pub fn to_titlecase(
     chunk: impl Into<Chunk>,
-    locale: InputLocale,
-    style: Option<StyleGuide>,
+    locale: impl Into<Locale>,
+    style: impl Into<StyleGuide>,
 ) -> String {
     let chunk: Chunk = chunk.into();
+    let locale: Locale = locale.into();
+    let style: StyleGuide = style.into();
     match locale {
-        InputLocale::EN => to_titlecase_en(chunk, style),
-        InputLocale::TR => to_titlecase_tr(chunk, style),
+        Locale::EN => to_titlecase_en(chunk, style),
+        Locale::TR => to_titlecase_tr(chunk, style),
     }
 }
 
 /// Convert a string to lower case following typesetting conventions for a target locale
-pub fn to_lowercase(chunk: impl Into<Chunk>, locale: impl Into<InputLocale>) -> String {
+pub fn to_lowercase(chunk: impl Into<Chunk>, locale: impl Into<Locale>) -> String {
     let chunk: Chunk = chunk.into();
-    let locale: InputLocale = locale.into();
+    let locale: Locale = locale.into();
     match locale {
-        InputLocale::EN => to_lowercase_en(chunk),
-        InputLocale::TR => to_lowercase_tr(chunk),
+        Locale::EN => to_lowercase_en(chunk),
+        Locale::TR => to_lowercase_tr(chunk),
     }
 }
 
 /// Convert a string to upper case following typesetting conventions for a target locale
-pub fn to_uppercase(chunk: impl Into<Chunk>, locale: impl Into<InputLocale>) -> String {
+pub fn to_uppercase(chunk: impl Into<Chunk>, locale: impl Into<Locale>) -> String {
     let chunk: Chunk = chunk.into();
-    let locale: InputLocale = locale.into();
+    let locale: Locale = locale.into();
     match locale {
-        InputLocale::EN => to_uppercase_en(chunk),
-        InputLocale::TR => to_uppercase_tr(chunk),
+        Locale::EN => to_uppercase_en(chunk),
+        Locale::TR => to_uppercase_tr(chunk),
     }
 }
 
 /// Convert a string to sentence case following typesetting conventions for a target locale
-pub fn to_sentencecase(chunk: impl Into<Chunk>, locale: impl Into<InputLocale>) -> String {
+pub fn to_sentencecase(chunk: impl Into<Chunk>, locale: impl Into<Locale>) -> String {
     let chunk: Chunk = chunk.into();
-    let locale: InputLocale = locale.into();
+    let locale: Locale = locale.into();
     match locale {
-        InputLocale::EN => to_sentencecase_en(chunk),
-        InputLocale::TR => to_sentencecase_tr(chunk),
+        Locale::EN => to_sentencecase_en(chunk),
+        Locale::TR => to_sentencecase_tr(chunk),
     }
 }
 
-fn to_titlecase_en(chunk: Chunk, style: Option<StyleGuide>) -> String {
+fn to_titlecase_en(chunk: Chunk, style: StyleGuide) -> String {
     match style {
-        Some(StyleGuide::AssociatedPress) => to_titlecase_ap(chunk),
-        Some(StyleGuide::ChicagoManualOfStyle) => to_titlecase_cmos(chunk),
-        Some(StyleGuide::DaringFireball) => to_titlecase_gruber(chunk),
-        None => to_titlecase_gruber(chunk),
+        StyleGuide::AssociatedPress => to_titlecase_ap(chunk),
+        StyleGuide::ChicagoManualOfStyle => to_titlecase_cmos(chunk),
+        StyleGuide::DaringFireball => to_titlecase_gruber(chunk),
+        StyleGuide::LanguageDefault => to_titlecase_gruber(chunk),
     }
 }
 
@@ -125,10 +146,9 @@ fn to_titlecase_gruber(chunk: Chunk) -> String {
     format!("{}{}{}", leading_trivia, titilized, trailing_trivia)
 }
 
-fn to_titlecase_tr(chunk: Chunk, style: Option<StyleGuide>) -> String {
+fn to_titlecase_tr(chunk: Chunk, style: StyleGuide) -> String {
     match style {
-        Some(_) => todo!("Turkish implementation doesn't support different style guides."),
-        None => {
+        StyleGuide::LanguageDefault => {
             let mut chunk = chunk.clone();
             let mut done_first = false;
             chunk.segments.iter_mut().for_each(|segment| {
@@ -146,6 +166,7 @@ fn to_titlecase_tr(chunk: Chunk, style: Option<StyleGuide>) -> String {
             });
             chunk.to_string()
         }
+        _ => todo!("Turkish implementation doesn't support different style guides."),
     }
 }
 
@@ -244,6 +265,52 @@ fn to_sentencecase_tr(chunk: Chunk) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn cast_from_str() {
+        let res = to_titlecase("FIST", "en", "gruber");
+        assert_eq!(res, "Fist");
+        let res = to_titlecase("FIST", "tr", "");
+        assert_eq!(res, "Fıst");
+        let res = to_titlecase("FIST", "tr", "default");
+        assert_eq!(res, "Fıst");
+    }
+
+    #[test]
+    fn cast_from_legacy_option() {
+        let res = to_titlecase("FIST", "en", Some(StyleGuide::DaringFireball));
+        assert_eq!(res, "Fist");
+        let res = to_titlecase("FIST", "en", None);
+        assert_eq!(res, "Fist");
+    }
+
+    macro_rules! case {
+        ($name:ident, $case:expr, $locale:expr, $style:expr, $input:expr, $expected:expr) => {
+            #[test]
+            fn $name() {
+                let actual = to_case($input, $case, $locale, $style);
+                assert_eq!(actual, $expected);
+            }
+        };
+    }
+
+    case!(
+        abc_title_me,
+        Case::Title,
+        Locale::EN,
+        StyleGuide::LanguageDefault,
+        "a b c",
+        "A B C"
+    );
+
+    case!(
+        abc_lower_me,
+        Case::Lower,
+        Locale::EN,
+        StyleGuide::LanguageDefault,
+        "A B C",
+        "a b c"
+    );
+
     macro_rules! titlecase {
         ($name:ident, $locale:expr, $style:expr, $input:expr, $expected:expr) => {
             #[test]
@@ -254,116 +321,122 @@ mod tests {
         };
     }
 
-    titlecase!(abc_none, InputLocale::EN, None, "a b c", "A B C");
+    titlecase!(
+        abc_none,
+        Locale::EN,
+        StyleGuide::LanguageDefault,
+        "a b c",
+        "A B C"
+    );
 
     titlecase!(
         abc_cmos,
-        InputLocale::EN,
-        Some(StyleGuide::ChicagoManualOfStyle),
+        Locale::EN,
+        StyleGuide::ChicagoManualOfStyle,
         "a b c",
         "A B C"
     );
 
     titlecase!(
         abc_gruber,
-        InputLocale::EN,
-        Some(StyleGuide::DaringFireball),
+        Locale::EN,
+        StyleGuide::DaringFireball,
         "a b c",
         "A B C"
     );
 
     titlecase!(
         simple_cmos,
-        InputLocale::EN,
-        Some(StyleGuide::ChicagoManualOfStyle),
+        Locale::EN,
+        StyleGuide::ChicagoManualOfStyle,
         "Once UPON A time",
         "Once upon a Time"
     );
 
     titlecase!(
         simple_gruber,
-        InputLocale::EN,
-        Some(StyleGuide::DaringFireball),
+        Locale::EN,
+        StyleGuide::DaringFireball,
         "Once UPON A time",
         "Once UPON a Time"
     );
 
     titlecase!(
         colon_cmos,
-        InputLocale::EN,
-        Some(StyleGuide::ChicagoManualOfStyle),
+        Locale::EN,
+        StyleGuide::ChicagoManualOfStyle,
         "foo: a baz",
         "Foo: a Baz"
     );
 
     titlecase!(
         colon_gruber,
-        InputLocale::EN,
-        Some(StyleGuide::DaringFireball),
+        Locale::EN,
+        StyleGuide::DaringFireball,
         "foo: a baz",
         "Foo: A Baz"
     );
 
     // titlecase!(
     //     qna_cmos,
-    //     InputLocale::EN,
-    //     Some(StyleGuide::ChicagoManualOfStyle),
+    //     Locale::EN,
+    //     StyleGuide::ChicagoManualOfStyle,
     //     "Q&A with Steve Jobs: 'That's what happens in technology'",
     //     "Q&a with Steve Jobs: 'that's What Happens in Technology'"
     // );
 
     titlecase!(
         qna_gruber,
-        InputLocale::EN,
-        Some(StyleGuide::DaringFireball),
+        Locale::EN,
+        StyleGuide::DaringFireball,
         "Q&A with Steve Jobs: 'That's what happens in technology'",
         "Q&A With Steve Jobs: 'That's What Happens in Technology'"
     );
 
     titlecase!(
         ws_gruber,
-        InputLocale::EN,
-        Some(StyleGuide::DaringFireball),
+        Locale::EN,
+        StyleGuide::DaringFireball,
         "  free  trolling\n  space  ",
         "  Free  Trolling\n  Space  "
     );
 
     titlecase!(
         turkish_question,
-        InputLocale::TR,
-        None,
+        Locale::TR,
+        StyleGuide::LanguageDefault,
         "aç mısın",
         "Aç mısın"
     );
 
     titlecase!(
         turkish_question_false,
-        InputLocale::TR,
-        None,
+        Locale::TR,
+        StyleGuide::LanguageDefault,
         "dualarımızda minnettarlık",
         "Dualarımızda Minnettarlık"
     );
 
     titlecase!(
         turkish_chars,
-        InputLocale::TR,
-        None,
+        Locale::TR,
+        StyleGuide::LanguageDefault,
         "İLKİ ILIK ÖĞLEN",
         "İlki Ilık Öğlen"
     );
 
     titlecase!(
         turkish_blockwords,
-        InputLocale::TR,
-        None,
+        Locale::TR,
+        StyleGuide::LanguageDefault,
         "Sen VE ben ile o",
         "Sen ve Ben ile O"
     );
 
     titlecase!(
         turkish_ws,
-        InputLocale::TR,
-        None,
+        Locale::TR,
+        StyleGuide::LanguageDefault,
         "  serbest  serseri\n  boşluk  ",
         "  Serbest  Serseri\n  Boşluk  "
     );
@@ -378,16 +451,11 @@ mod tests {
         };
     }
 
-    lowercase!(
-        lower_en,
-        InputLocale::EN,
-        "foo BAR BaZ BIKE",
-        "foo bar baz bike"
-    );
+    lowercase!(lower_en, Locale::EN, "foo BAR BaZ BIKE", "foo bar baz bike");
 
     lowercase!(
         lower_tr,
-        InputLocale::TR,
+        Locale::TR,
         "foo BAR BaZ ILIK İLE",
         "foo bar baz ılık ile"
     );
@@ -402,16 +470,11 @@ mod tests {
         };
     }
 
-    uppercase!(
-        upper_en,
-        InputLocale::EN,
-        "foo BAR BaZ bike",
-        "FOO BAR BAZ BIKE"
-    );
+    uppercase!(upper_en, Locale::EN, "foo BAR BaZ bike", "FOO BAR BAZ BIKE");
 
     uppercase!(
         upper_tr,
-        InputLocale::TR,
+        Locale::TR,
         "foo BAR BaZ ILIK İLE",
         "FOO BAR BAZ ILIK İLE"
     );
@@ -428,15 +491,10 @@ mod tests {
 
     sentencecase!(
         sentence_en,
-        InputLocale::EN,
+        Locale::EN,
         "insert BIKE here",
         "Insert bike here"
     );
 
-    sentencecase!(
-        sentence_tr,
-        InputLocale::TR,
-        "ilk DAVRANSIN",
-        "İlk davransın"
-    );
+    sentencecase!(sentence_tr, Locale::TR, "ilk DAVRANSIN", "İlk davransın");
 }