decasify 0.7.0__tar.gz → 0.7.1__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: decasify
-Version: 0.7.0
+Version: 0.7.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English

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

@@ -26,6 +26,25 @@ 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>,
@@ -264,6 +283,34 @@ mod tests {
         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]

{decasify-0.7.0 → decasify-0.7.1}/src/lua.rs

@@ -4,11 +4,13 @@
 use crate::*;
 use mlua::prelude::*;
 
-pub use crate::types::{Locale, Result, StyleGuide};
+pub use crate::types::{Case, Locale, Result, StyleGuide};
 
 #[mlua::lua_module]
 fn decasify(lua: &Lua) -> LuaResult<LuaTable> {
     let exports = lua.create_table().unwrap();
+    let case = lua.create_function(case)?;
+    exports.set("case", case).unwrap();
     let titlecase = lua.create_function(titlecase)?;
     exports.set("titlecase", titlecase).unwrap();
     let lowercase = lua.create_function(lowercase)?;
@@ -23,6 +25,30 @@ fn decasify(lua: &Lua) -> LuaResult<LuaTable> {
     Ok(exports)
 }
 
+fn case<'a>(
+    lua: &'a Lua,
+    (input, case, locale, style): (LuaString<'a>, LuaValue<'a>, LuaValue<'a>, LuaValue<'a>),
+) -> LuaResult<LuaString<'a>> {
+    let input = input.to_string_lossy();
+    let case: Case = match case {
+        LuaValue::String(s) => s.to_string_lossy().parse().unwrap_or(Case::Title),
+        _ => Case::Title,
+    };
+    let locale: Locale = match locale {
+        LuaValue::String(s) => s.to_string_lossy().parse().unwrap_or(Locale::EN),
+        _ => Locale::EN,
+    };
+    let style: StyleGuide = match style {
+        LuaValue::String(s) => s
+            .to_string_lossy()
+            .parse()
+            .unwrap_or(StyleGuide::LanguageDefault),
+        _ => StyleGuide::LanguageDefault,
+    };
+    let output = to_case(&input, case, locale, style);
+    lua.create_string(output)
+}
+
 fn titlecase<'a>(
     lua: &'a Lua,
     (input, locale, style): (LuaString<'a>, LuaValue<'a>, LuaValue<'a>),

{decasify-0.7.0 → decasify-0.7.1}/src/python.rs

@@ -4,12 +4,14 @@
 use crate::*;
 use pyo3::prelude::*;
 
-pub use crate::types::{Locale, Result, StyleGuide};
+pub use crate::types::{Case, Locale, Result, StyleGuide};
 
 #[pymodule]
 fn decasify(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_class::<Case>()?;
     module.add_class::<Locale>()?;
     module.add_class::<StyleGuide>()?;
+    module.add_function(wrap_pyfunction!(py_case, module)?)?;
     module.add_function(wrap_pyfunction!(py_titlecase, module)?)?;
     module.add_function(wrap_pyfunction!(py_lowercase, module)?)?;
     module.add_function(wrap_pyfunction!(py_uppercase, module)?)?;
@@ -17,6 +19,13 @@ fn decasify(module: &Bound<'_, PyModule>) -> PyResult<()> {
     Ok(())
 }
 
+#[pyfunction]
+#[pyo3(name = "case")]
+#[pyo3(signature = (input, case, locale, style=StyleGuide::LanguageDefault))]
+fn py_case(input: String, case: Case, locale: Locale, style: StyleGuide) -> PyResult<String> {
+    Ok(to_case(&input, case, locale, style))
+}
+
 #[pyfunction]
 #[pyo3(name = "titlecase")]
 #[pyo3(signature = (input, locale, style=StyleGuide::LanguageDefault))]

{decasify-0.7.0 → decasify-0.7.1}/src/types.rs

@@ -37,6 +37,8 @@ pub enum Locale {
 
 /// Target case selector.
 #[derive(Default, Display, VariantNames, Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "pythonmodule", pyclass(eq, eq_int))]
+#[cfg_attr(feature = "wasm", wasm_bindgen)]
 #[strum(serialize_all = "lowercase")]
 #[non_exhaustive]
 pub enum Case {
@@ -95,6 +97,12 @@ impl FromStr for Case {
     }
 }
 
+impl From<&str> for Case {
+    fn from(s: &str) -> Self {
+        Self::from_str(s).unwrap()
+    }
+}
+
 impl FromStr for StyleGuide {
     type Err = Box<dyn error::Error>;
     fn from_str(s: &str) -> Result<Self> {

{decasify-0.7.0 → decasify-0.7.1}/src/wasm.rs

@@ -5,7 +5,12 @@ use crate::*;
 use std::result::Result;
 use wasm_bindgen::prelude::*;
 
-pub use crate::types::{Locale, StyleGuide};
+pub use crate::types::{Case, Locale, StyleGuide};
+
+#[wasm_bindgen]
+pub fn case(input: &str, case: Case, locale: Locale, style: StyleGuide) -> Result<String, JsError> {
+    Ok(to_case(input, case, locale, style))
+}
 
 #[wasm_bindgen]
 pub fn titlecase(input: &str, locale: Locale, style: StyleGuide) -> Result<String, JsError> {