decasify 0.10.2__tar.gz → 0.11.0__tar.gz

{decasify-0.10.2 → decasify-0.11.0}/Cargo.lock

@@ -307,7 +307,7 @@ dependencies = [
 
 [[package]]
 name = "decasify"
-version = "0.10.2"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1977,7 +1977,7 @@ dependencies = [
 
 [[package]]
 name = "typst"
-version = "0.10.2"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "decasify",

{decasify-0.10.2 → decasify-0.11.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "decasify"
-version = "0.10.2"
+version = "0.11.0"
 description = "A CLI utility and library to cast strings to title-case according to locale specific style guides including Turkish support"
 readme = "README.md"
 build = "build-aux/build.rs"
@@ -13,7 +13,7 @@ repository.workspace = true
 license.workspace = true
 
 [workspace.package]
-version = "0.10.2"
+version = "0.11.0"
 authors = ["Caleb Maclennan <caleb@alerque.com>"]
 homepage = "https://github.com/alerque/decasify"
 repository = "https://github.com/alerque/decasify"
@@ -64,7 +64,7 @@ wasm = ["dep:wasm-bindgen"]
 
 [workspace.dependencies.decasify]
 path = "."
-version = "0.10.2"
+version = "0.11.0"
 
 [dependencies]
 regex = "1.11"
@@ -167,6 +167,7 @@ extend-ignore-identifiers-re = ["[bB][aA][zZ]"]
 
 [package.metadata.typos.default.extend-words]
 runing = "running"
+walm = "wasm"
 
 [package.metadata.typos.files]
 ignore-hidden = false

{decasify-0.10.2 → decasify-0.11.0}/PKG-INFO

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

{decasify-0.10.2 → decasify-0.11.0}/README.md

@@ -92,7 +92,7 @@ In your `Cargo.toml` file.
 
 ```toml
 [dependencies]
-decasify = "0.10"
+decasify = "0.11"
 ```
 
 Then use the crate functions and types in your project something like this:
@@ -103,10 +103,10 @@ use decasify::{Locale, StyleGuide, StyleOptions};
 
 fn demo() {
     let input = "ILIK SU VE İTEN RÜZGARLAR";
-    let output = titlecase(input, Locale::TR, StyleGuide::LanguageDefault, StyleOptions::default());
+    let output = titlecase(input, Locale::TR, StyleGuide::LanguageDefault, StyleOptions::default()).unwrap();
     eprintln! {"{output}"};
     let input = "title with a twist: a colon";
-    let output = titlecase(input, Locale::EN, StyleGuide::DaringFireball, StyleOptions::default());
+    let output = titlecase(input, Locale::EN, StyleGuide::DaringFireball, StyleOptions::default()).unwrap();
     eprintln! {"{output}"};
 }
 ```
@@ -259,7 +259,7 @@ The [decasify](https://typst.app/universe/package/decasify) package can be added
 The exact version must be specified explicitly:
 
 ```typst
-#import "@preview/decasify:0.10.2": *
+#import "@preview/decasify:0.11.0": *
 ```
 
 Specific functions for each case should be available throughout the document.

{decasify-0.10.2 → decasify-0.11.0}/src/bin/decasify.rs

@@ -1,53 +1,30 @@
 // SPDX-FileCopyrightText: © 2023 Caleb Maclennan <caleb@alerque.com>
 // SPDX-License-Identifier: LGPL-3.0-only
 
-use decasify::cli::Cli;
-use decasify::{lowercase, sentencecase, titlecase, uppercase};
-use decasify::{Case, Locale, StyleGuide, StyleOptions, StyleOptionsBuilder};
-
-use snafu::prelude::*;
-
 use clap::CommandFactory;
 use std::io;
 use std::io::BufRead;
 
-#[derive(Snafu)]
-enum Error {
-    #[snafu(display("Failed to identify input"))]
-    Input {},
-
-    #[snafu(display("Failed to resolve a known locale"))]
-    Locale {},
-
-    #[snafu(display("Failed to resolve a known case"))]
-    Case {},
-
-    #[snafu(display("Failed to resolve a known style guide"))]
-    StyleGuide {},
-}
-
-// Clap CLI errors are reported using the Debug trait, but Snafu sets up the Display trait.
-// So we delegate. c.f. https://github.com/shepmaster/snafu/issues/110
-impl std::fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        std::fmt::Display::fmt(self, fmt)
-    }
-}
-
-type Result<T, E = Error> = std::result::Result<T, E>;
+use decasify::cli::Cli;
+use decasify::types::Result;
+use decasify::{lowercase, sentencecase, titlecase, uppercase};
+use decasify::{Case, Locale, StyleGuide, StyleOptions, StyleOptionsBuilder};
 
 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::<Locale>("locale").context(LocaleSnafu)?;
+    let locale = matches
+        .get_one::<Locale>("locale")
+        .unwrap_or(&Locale::default())
+        .to_owned();
     let case = matches
         .get_one::<Case>("case")
-        .context(CaseSnafu)?
+        .unwrap_or(&Case::default())
         .to_owned();
     let style = matches
         .get_one::<StyleGuide>("style")
-        .context(StyleGuideSnafu)?
+        .unwrap_or(&StyleGuide::default())
         .to_owned();
     let opts = if let Some(overrides) = matches.get_many::<String>("overrides") {
         StyleOptionsBuilder::new()
@@ -60,27 +37,23 @@ fn main() -> Result<()> {
         true => {
             let input: Vec<String> = matches
                 .get_many::<String>("input")
-                .context(InputSnafu)?
+                .unwrap()
                 .cloned()
                 .collect();
             let input: Vec<String> = vec![input.join(" ")];
             process(
                 input.iter().map(|ln| ln.to_string()),
-                *locale,
+                locale,
                 case,
                 style,
                 opts,
-            );
+            )
+        }
+        false => {
+            let stdin = io::stdin().lock().lines().map(|ln| ln.unwrap());
+            process(stdin, locale, case, style, opts)
         }
-        false => process(
-            io::stdin().lock().lines().map(|ln| ln.unwrap()),
-            *locale,
-            case,
-            style,
-            opts,
-        ),
     }
-    Ok(())
 }
 
 fn process<I: IntoIterator<Item = String>>(
@@ -89,15 +62,16 @@ fn process<I: IntoIterator<Item = String>>(
     case: Case,
     style: StyleGuide,
     opts: StyleOptions,
-) {
+) -> Result<()> {
     for string in strings {
         let output = match case {
-            Case::Title => titlecase(string, locale, style.clone(), opts.clone()),
-            Case::Lower => lowercase(string, locale),
-            Case::Upper => uppercase(string, locale),
-            Case::Sentence => sentencecase(string, locale),
+            Case::Title => titlecase(string, locale, style.clone(), opts.clone())?,
+            Case::Lower => lowercase(string, locale)?,
+            Case::Upper => uppercase(string, locale)?,
+            Case::Sentence => sentencecase(string, locale)?,
             _ => unreachable!(),
         };
-        println!("{output}")
+        println!("{output}");
     }
+    Ok(())
 }

{decasify-0.10.2 → decasify-0.11.0}/src/content.rs

@@ -1,13 +1,11 @@
 // SPDX-FileCopyrightText: © 2023 Caleb Maclennan <caleb@alerque.com>
 // SPDX-License-Identifier: LGPL-3.0-only
 
-pub use crate::types::Word;
-
 use regex::Regex;
 use std::{borrow::Cow, fmt, fmt::Display, str::FromStr};
 use unicode_titlecase::StrTitleCase;
 
-use snafu::prelude::*;
+use crate::types::{Error, Result, Word};
 
 #[derive(Clone, Debug)]
 #[non_exhaustive]
@@ -22,22 +20,6 @@ pub enum Segment {
     Word(Word),
 }
 
-#[derive(Snafu)]
-pub enum Error {
-    #[snafu(display("Unable to cast str to Chunk"))]
-    StrToChunk {},
-}
-
-// Clap CLI errors are reported using the Debug trait, but Snafu sets up the Display trait.
-// So we delegate. c.f. https://github.com/shepmaster/snafu/issues/110
-impl std::fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        std::fmt::Display::fmt(self, fmt)
-    }
-}
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
 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();

{decasify-0.10.2 → decasify-0.11.0}/src/lib.rs

@@ -6,12 +6,13 @@
 
 mod content;
 mod traits;
-mod types;
+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)]
@@ -33,18 +34,28 @@ mod en;
 mod tr;
 
 /// Convert a string to a specific case following typesetting conventions for a target locale
-pub fn case(
+pub fn case<TC, TL, TS, TO>(
     chunk: impl Into<Chunk>,
-    case: impl Into<Case>,
-    locale: impl Into<Locale>,
-    style: impl Into<StyleGuide>,
-    opts: impl Into<StyleOptions>,
-) -> String {
+    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.into();
-    let locale: Locale = locale.into();
-    let style: StyleGuide = style.into();
-    let opts: StyleOptions = opts.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),
@@ -54,50 +65,70 @@ pub fn case(
 }
 
 /// Convert a string to title case following typesetting conventions for a target locale
-pub fn titlecase(
+pub fn titlecase<TL, TS, TO>(
     chunk: impl Into<Chunk>,
-    locale: impl Into<Locale>,
-    style: impl Into<StyleGuide>,
-    opts: impl Into<StyleOptions>,
-) -> String {
+    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.into();
-    let style: StyleGuide = style.into();
-    let opts: StyleOptions = opts.into();
-    match locale {
+    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::TR => tr::titlecase(chunk, style, opts),
-    }
+    })
 }
 
 /// Convert a string to lower case following typesetting conventions for a target locale
-pub fn lowercase(chunk: impl Into<Chunk>, locale: impl Into<Locale>) -> String {
+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.into();
-    match locale {
+    let locale: Locale = locale.try_into()?;
+    Ok(match locale {
         Locale::EN => en::lowercase(chunk),
         Locale::TR => tr::lowercase(chunk),
-    }
+    })
 }
 
 /// Convert a string to upper case following typesetting conventions for a target locale
-pub fn uppercase(chunk: impl Into<Chunk>, locale: impl Into<Locale>) -> String {
+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.into();
-    match locale {
+    let locale: Locale = locale.try_into()?;
+    Ok(match locale {
         Locale::EN => en::uppercase(chunk),
         Locale::TR => tr::uppercase(chunk),
-    }
+    })
 }
 
 /// Convert a string to sentence case following typesetting conventions for a target locale
-pub fn sentencecase(chunk: impl Into<Chunk>, locale: impl Into<Locale>) -> String {
+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.into();
-    match locale {
+    let locale: Locale = locale.try_into()?;
+    Ok(match locale {
         Locale::EN => en::sentencecase(chunk),
         Locale::TR => tr::sentencecase(chunk),
-    }
+    })
 }
 
 fn get_override<F>(word: &Word, overrides: &Option<Vec<Word>>, case_fn: F) -> Option<Word>

decasify-0.11.0/src/lua.rs

@@ -0,0 +1,190 @@
+// SPDX-FileCopyrightText: © 2023 Caleb Maclennan <caleb@alerque.com>
+// SPDX-License-Identifier: LGPL-3.0-only
+
+use crate::*;
+use mlua::prelude::*;
+
+use crate::types::{Error, Result};
+
+macro_rules! impl_into_luaresult {
+    ($($t:ty),*) => {
+        $(
+            impl Into<LuaResult<$t>> for $t {
+                fn into(self) -> LuaResult<$t> {
+                    Ok(self)
+                }
+            }
+        )*
+    };
+}
+
+impl_into_luaresult!(Locale, Case, StyleGuide, StyleOptions);
+
+impl From<Error> for LuaError {
+    fn from(err: Error) -> LuaError {
+        LuaError::RuntimeError(err.to_string())
+    }
+}
+
+impl TryFrom<LuaString> for Locale {
+    type Error = Error;
+    fn try_from(s: LuaString) -> Result<Self> {
+        s.to_string_lossy().try_into()
+    }
+}
+
+impl TryFrom<LuaString> for Case {
+    type Error = Error;
+    fn try_from(s: LuaString) -> Result<Self> {
+        s.to_string_lossy().try_into()
+    }
+}
+
+impl TryFrom<LuaString> for StyleGuide {
+    type Error = Error;
+    fn try_from(s: LuaString) -> Result<Self> {
+        s.to_string_lossy().try_into()
+    }
+}
+
+#[mlua::lua_module]
+fn decasify(lua: &Lua) -> LuaResult<LuaTable> {
+    let exports = lua.create_table()?;
+    exports.set(
+        "case",
+        lua.create_function(
+            |_,
+             (chunk, case_, locale, styleguide, styleoptions): (
+                Chunk,
+                Case,
+                Locale,
+                StyleGuide,
+                StyleOptions,
+            )| { Ok(case(chunk, case_, locale, styleguide, styleoptions)?) },
+        )?,
+    )?;
+    exports.set(
+        "titlecase",
+        lua.create_function(
+            |_,
+             (chunk, locale, styleguide, styleoptions): (
+                Chunk,
+                Locale,
+                StyleGuide,
+                StyleOptions,
+            )| { Ok(titlecase(chunk, locale, styleguide, styleoptions)?) },
+        )?,
+    )?;
+    exports.set(
+        "lowercase",
+        lua.create_function(|_, (chunk, locale): (Chunk, Locale)| Ok(lowercase(chunk, locale)?))?,
+    )?;
+    exports.set(
+        "uppercase",
+        lua.create_function(|_, (chunk, locale): (Chunk, Locale)| Ok(uppercase(chunk, locale)?))?,
+    )?;
+    exports.set(
+        "sentencecase",
+        lua.create_function(|_, (chunk, locale): (Chunk, Locale)| {
+            Ok(sentencecase(chunk, locale)?)
+        })?,
+    )?;
+    let mt = lua.create_table()?;
+    let decasify = lua.create_function(
+        move |_,
+              (_, chunk, case_, locale, styleguide, styleoptions): (
+            LuaTable,
+            Chunk,
+            Case,
+            Locale,
+            StyleGuide,
+            Option<StyleOptions>,
+        )| {
+            Ok(case(
+                chunk,
+                case_,
+                locale,
+                styleguide,
+                styleoptions.unwrap_or_default(),
+            )?)
+        },
+    )?;
+    mt.set("__call", decasify)?;
+    exports.set_metatable(Some(mt))?;
+    let version = option_env!("VERGEN_GIT_DESCRIBE").unwrap_or_else(|| env!("CARGO_PKG_VERSION"));
+    let version = lua.create_string(version)?;
+    exports.set("version", version)?;
+    Ok(exports)
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
+impl FromLua for Chunk {
+    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
+        let chunk = match value {
+            LuaValue::String(s) => s.to_string_lossy(),
+            _ => String::from(""),
+        }
+        .into();
+        Ok(chunk)
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
+impl FromLua for Locale {
+    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
+        match value {
+            LuaValue::String(s) => s.try_into()?,
+            LuaValue::Nil => Self::default(),
+            _ => value.to_string().unwrap_or_default().try_into()?,
+        }
+        .into()
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
+impl FromLua for Case {
+    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
+        match value {
+            LuaValue::String(s) => s.try_into()?,
+            LuaValue::Nil => Self::default(),
+            _ => value.to_string().unwrap_or_default().try_into()?,
+        }
+        .into()
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
+impl FromLua for StyleGuide {
+    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
+        match value {
+            LuaValue::String(s) => s.try_into()?,
+            LuaValue::Nil => Self::default(),
+            _ => value.to_string().unwrap_or_default().try_into()?,
+        }
+        .into()
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
+impl FromLua for StyleOptions {
+    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
+        match value {
+            LuaValue::Table(t) => {
+                let mut builder = StyleOptionsBuilder::new();
+                if let Ok(overrides_table) = t.get::<LuaTable>("overrides") {
+                    let overrides: Vec<Word> = overrides_table
+                        .sequence_values::<String>()
+                        .collect::<LuaResult<Vec<_>>>()?
+                        .into_iter()
+                        .map(|s| s.into())
+                        .collect();
+                    builder = builder.overrides(overrides);
+                }
+                builder.build()
+            }
+            LuaValue::Nil => Self::default(),
+            _ => value.to_string().unwrap_or_default().try_into()?,
+        }
+        .into()
+    }
+}

{decasify-0.10.2 → decasify-0.11.0}/src/python.rs

@@ -4,6 +4,12 @@
 use crate::types::*;
 use pyo3::prelude::*;
 
+impl From<crate::types::Error> for PyErr {
+    fn from(err: crate::types::Error) -> Self {
+        pyo3::exceptions::PyValueError::new_err(err.to_string())
+    }
+}
+
 #[pymodule]
 fn decasify(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_class::<Case>()?;
@@ -33,7 +39,7 @@ fn case(
         Some(words) => StyleOptionsBuilder::new().overrides(words).build(),
         None => StyleOptions::default(),
     };
-    Ok(crate::case(&input, case, locale, style, opts))
+    Ok(crate::case(&input, case, locale, style, opts)?)
 }
 
 #[pyfunction]
@@ -48,23 +54,23 @@ fn titlecase(
         Some(words) => StyleOptionsBuilder::new().overrides(words).build(),
         None => StyleOptions::default(),
     };
-    Ok(crate::titlecase(&input, locale, style, opts))
+    Ok(crate::titlecase(&input, locale, style, opts)?)
 }
 
 #[pyfunction]
 #[pyo3(signature = (input, locale))]
 fn lowercase(input: String, locale: Locale) -> PyResult<String> {
-    Ok(crate::lowercase(&input, locale))
+    Ok(crate::lowercase(&input, locale)?)
 }
 
 #[pyfunction]
 #[pyo3(signature = (input, locale))]
 fn uppercase(input: String, locale: Locale) -> PyResult<String> {
-    Ok(crate::uppercase(&input, locale))
+    Ok(crate::uppercase(&input, locale)?)
 }
 
 #[pyfunction]
 #[pyo3(signature = (input, locale))]
 fn sentencecase(input: String, locale: Locale) -> PyResult<String> {
-    Ok(crate::sentencecase(&input, locale))
+    Ok(crate::sentencecase(&input, locale)?)
 }

{decasify-0.10.2 → decasify-0.11.0}/src/types.rs

@@ -1,11 +1,12 @@
 // SPDX-FileCopyrightText: © 2023 Caleb Maclennan <caleb@alerque.com>
 // SPDX-License-Identifier: LGPL-3.0-only
 
+use snafu::prelude::*;
+use std::convert::{Infallible, TryFrom};
+use std::fmt::{Debug, Display, Formatter};
 use std::str::FromStr;
 use strum_macros::{Display, VariantNames};
 
-use snafu::prelude::*;
-
 #[cfg(feature = "pythonmodule")]
 use pyo3::prelude::*;
 
@@ -13,25 +14,32 @@ use pyo3::prelude::*;
 use wasm_bindgen::prelude::*;
 
 #[derive(Snafu)]
+#[snafu(visibility(pub))]
 pub enum Error {
-    #[snafu(display("Invalid input language {}", input))]
+    #[snafu(display("Invalid input language '{input}'"))]
     Locale { input: String },
 
-    #[snafu(display("Invalid target case {}", input))]
+    #[snafu(display("Invalid target case '{input}'"))]
     Case { input: String },
 
-    #[snafu(display("Invalid preferred style guide {}", input))]
+    #[snafu(display("Invalid preferred style guide '{input}'"))]
     StyleGuide { input: String },
 
-    #[snafu(display("Invalid style options {}", input))]
+    #[snafu(display("Invalid style options '{input}'"))]
     StyleOptions { input: String },
 }
 
 // Clap CLI errors are reported using the Debug trait, but Snafu sets up the Display trait.
 // So we delegate. c.f. https://github.com/shepmaster/snafu/issues/110
-impl std::fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        std::fmt::Display::fmt(self, fmt)
+impl Debug for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> std::fmt::Result {
+        Display::fmt(self, fmt)
+    }
+}
+
+impl From<Infallible> for Error {
+    fn from(_: Infallible) -> Self {
+        unreachable!()
     }
 }
 
@@ -99,12 +107,6 @@ pub struct StyleOptions {
     pub overrides: Option<Vec<Word>>,
 }
 
-impl From<&str> for StyleOptions {
-    fn from(s: &str) -> Self {
-        Self::from_str(s).unwrap()
-    }
-}
-
 impl FromStr for StyleOptions {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self> {
@@ -115,6 +117,35 @@ impl FromStr for StyleOptions {
     }
 }
 
+impl TryFrom<&str> for StyleOptions {
+    type Error = Error;
+    fn try_from(s: &str) -> Result<Self> {
+        Self::from_str(s)
+    }
+}
+
+impl TryFrom<String> for StyleOptions {
+    type Error = Error;
+    fn try_from(s: String) -> Result<Self> {
+        Self::from_str(&s)
+    }
+}
+
+impl TryFrom<&String> for StyleOptions {
+    type Error = Error;
+    fn try_from(s: &String) -> Result<Self> {
+        Self::from_str(s)
+    }
+}
+
+impl TryFrom<&[u8]> for StyleOptions {
+    type Error = Error;
+    fn try_from(s: &[u8]) -> Result<Self> {
+        let s = String::from_utf8_lossy(s);
+        Self::from_str(&s)
+    }
+}
+
 #[derive(Debug)]
 pub struct StyleOptionsBuilder {
     overrides: Option<Vec<Word>>,
@@ -155,28 +186,33 @@ impl FromStr for Locale {
     }
 }
 
-impl From<&str> for Locale {
-    fn from(s: &str) -> Self {
-        Self::from_str(s).unwrap()
+impl TryFrom<&str> for Locale {
+    type Error = Error;
+    fn try_from(s: &str) -> Result<Self> {
+        Self::from_str(s)
     }
 }
 
-impl From<String> for Locale {
-    fn from(s: String) -> Self {
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<String> for Locale {
+    type Error = Error;
+    fn try_from(s: String) -> Result<Self> {
+        Self::from_str(&s)
     }
 }
 
-impl From<&String> for Locale {
-    fn from(s: &String) -> Self {
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<&String> for Locale {
+    type Error = Error;
+    fn try_from(s: &String) -> Result<Self> {
+        Self::from_str(s)
     }
 }
 
-impl From<&[u8]> for Locale {
-    fn from(s: &[u8]) -> Self {
-        let s = String::from_utf8(s.to_vec()).unwrap();
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<&[u8]> for Locale {
+    type Error = Error;
+
+    fn try_from(s: &[u8]) -> Result<Self> {
+        let s = String::from_utf8_lossy(s);
+        Self::from_str(&s)
     }
 }
 
@@ -193,28 +229,33 @@ impl FromStr for Case {
     }
 }
 
-impl From<&str> for Case {
-    fn from(s: &str) -> Self {
-        Self::from_str(s).unwrap()
+impl TryFrom<&str> for Case {
+    type Error = Error;
+    fn try_from(s: &str) -> Result<Self> {
+        Self::from_str(s)
     }
 }
 
-impl From<String> for Case {
-    fn from(s: String) -> Self {
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<String> for Case {
+    type Error = Error;
+    fn try_from(s: String) -> Result<Self> {
+        Self::from_str(&s)
     }
 }
 
-impl From<&String> for Case {
-    fn from(s: &String) -> Self {
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<&String> for Case {
+    type Error = Error;
+    fn try_from(s: &String) -> Result<Self> {
+        Self::from_str(s)
     }
 }
 
-impl From<&[u8]> for Case {
-    fn from(s: &[u8]) -> Self {
-        let s = String::from_utf8(s.to_vec()).unwrap();
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<&[u8]> for Case {
+    type Error = Error;
+
+    fn try_from(s: &[u8]) -> Result<Self> {
+        let s = String::from_utf8_lossy(s);
+        Self::from_str(&s)
     }
 }
 
@@ -234,28 +275,24 @@ impl FromStr for StyleGuide {
     }
 }
 
-impl From<&str> for StyleGuide {
-    fn from(s: &str) -> Self {
-        Self::from_str(s).unwrap()
+impl TryFrom<&str> for StyleGuide {
+    type Error = Error;
+    fn try_from(s: &str) -> Result<Self> {
+        Self::from_str(s)
     }
 }
 
-impl From<String> for StyleGuide {
-    fn from(s: String) -> Self {
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<String> for StyleGuide {
+    type Error = Error;
+    fn try_from(s: String) -> Result<Self> {
+        Self::from_str(&s)
     }
 }
 
-impl From<&String> for StyleGuide {
-    fn from(s: &String) -> Self {
-        Self::from_str(s.as_ref()).unwrap()
-    }
-}
-
-impl From<&[u8]> for StyleGuide {
-    fn from(s: &[u8]) -> Self {
-        let s = String::from_utf8(s.to_vec()).unwrap();
-        Self::from_str(s.as_ref()).unwrap()
+impl TryFrom<&String> for StyleGuide {
+    type Error = Error;
+    fn try_from(s: &String) -> Result<Self> {
+        Self::from_str(s)
     }
 }
 
@@ -267,3 +304,12 @@ impl From<Option<StyleGuide>> for StyleGuide {
         }
     }
 }
+
+impl TryFrom<&[u8]> for StyleGuide {
+    type Error = Error;
+
+    fn try_from(s: &[u8]) -> Result<Self> {
+        let s = String::from_utf8_lossy(s);
+        Self::from_str(&s)
+    }
+}

{decasify-0.10.2 → decasify-0.11.0}/src/wasm.rs

@@ -15,7 +15,7 @@ pub fn case(
     opts: Option<StyleOptions>,
 ) -> Result<String, JsError> {
     let opts = opts.unwrap_or_default();
-    Ok(crate::case(input, case, locale, style, opts))
+    Ok(crate::case(input, case, locale, style, opts)?)
 }
 
 #[wasm_bindgen]
@@ -26,20 +26,20 @@ pub fn titlecase(
     opts: Option<StyleOptions>,
 ) -> Result<String, JsError> {
     let opts = opts.unwrap_or_default();
-    Ok(crate::titlecase(input, locale, style, opts))
+    Ok(crate::titlecase(input, locale, style, opts)?)
 }
 
 #[wasm_bindgen]
 pub fn lowercase(input: &str, locale: Locale) -> Result<String, JsError> {
-    Ok(crate::lowercase(input, locale))
+    Ok(crate::lowercase(input, locale)?)
 }
 
 #[wasm_bindgen]
 pub fn uppercase(input: &str, locale: Locale) -> Result<String, JsError> {
-    Ok(crate::uppercase(input, locale))
+    Ok(crate::uppercase(input, locale)?)
 }
 
 #[wasm_bindgen]
 pub fn sentencecase(input: &str, locale: Locale) -> Result<String, JsError> {
-    Ok(crate::sentencecase(input, locale))
+    Ok(crate::sentencecase(input, locale)?)
 }

{decasify-0.10.2 → decasify-0.11.0}/tests/lib.rs

@@ -5,11 +5,11 @@ use decasify::*;
 
 #[test]
 fn cast_from_str() {
-    let res = titlecase("FIST", "en", "gruber", "default");
+    let res = titlecase("FIST", "en", "gruber", "default").unwrap();
     assert_eq!(res, "Fist");
-    let res = titlecase("FIST", "tr", "", "default");
+    let res = titlecase("FIST", "tr", "", "default").unwrap();
     assert_eq!(res, "Fıst");
-    let res = titlecase("FIST", "tr", "default", "default");
+    let res = titlecase("FIST", "tr", "default", "default").unwrap();
     assert_eq!(res, "Fıst");
 }
 
@@ -20,23 +20,24 @@ fn cast_from_legacy_option() {
         "en",
         Some(StyleGuide::DaringFireball),
         StyleOptions::default(),
-    );
+    )
+    .unwrap();
     assert_eq!(res, "Fist");
-    let res = titlecase("FIST", "en", None, StyleOptions::default());
+    let res = titlecase("FIST", "en", None, StyleOptions::default()).unwrap();
     assert_eq!(res, "Fist");
 }
 
 #[test]
 fn custom_style_guide() {
     let options: StyleOptions = StyleOptionsBuilder::new().overrides(vec!["fOO"]).build();
-    let res = titlecase("foo bar", "tr", StyleGuide::LanguageDefault, options);
+    let res = titlecase("foo bar", "tr", StyleGuide::LanguageDefault, options).unwrap();
     assert_eq!(res, "fOO Bar");
 }
 
 #[cfg(feature = "unstable-trait")]
 #[test]
 fn trait_chery() {
-    use decasify::Decasify;
+    use Decasify::Decasify;
     let s = "WHY THE LONG FACE?";
     assert_eq!(s.to_case("sentence", "en", None), "Why the long face?");
     assert_eq!(
@@ -53,7 +54,7 @@ macro_rules! case {
     ($name:ident, $case:expr, $locale:expr, $style:expr, $opts:expr, $input:expr, $expected:expr) => {
         #[test]
         fn $name() {
-            let actual = case($input, $case, $locale, $style, $opts);
+            let actual = case($input, $case, $locale, $style, $opts).unwrap();
             assert_eq!(actual, $expected);
         }
     };
@@ -103,7 +104,7 @@ macro_rules! titlecase {
     ($name:ident, $locale:expr, $style:expr, $opts:expr, $input:expr, $expected:expr) => {
         #[test]
         fn $name() {
-            let actual = titlecase($input, $locale, $style, $opts);
+            let actual = titlecase($input, $locale, $style, $opts).unwrap();
             assert_eq!(actual, $expected);
         }
     };
@@ -247,7 +248,7 @@ macro_rules! lowercase {
     ($name:ident, $locale:expr, $input:expr, $expected:expr) => {
         #[test]
         fn $name() {
-            let actual = lowercase($input, $locale);
+            let actual = lowercase($input, $locale).unwrap();
             assert_eq!(actual, $expected);
         }
     };
@@ -266,7 +267,7 @@ macro_rules! uppercase {
     ($name:ident, $locale:expr, $input:expr, $expected:expr) => {
         #[test]
         fn $name() {
-            let actual = uppercase($input, $locale);
+            let actual = uppercase($input, $locale).unwrap();
             assert_eq!(actual, $expected);
         }
     };
@@ -285,7 +286,7 @@ macro_rules! sentencecase {
     ($name:ident, $locale:expr, $input:expr, $expected:expr) => {
         #[test]
         fn $name() {
-            let actual = sentencecase($input, $locale);
+            let actual = sentencecase($input, $locale).unwrap();
             assert_eq!(actual, $expected);
         }
     };

decasify-0.10.2/src/lua.rs

@@ -1,122 +0,0 @@
-// SPDX-FileCopyrightText: © 2023 Caleb Maclennan <caleb@alerque.com>
-// SPDX-License-Identifier: LGPL-3.0-only
-
-use crate::*;
-use mlua::prelude::*;
-
-#[mlua::lua_module]
-fn decasify(lua: &Lua) -> LuaResult<LuaTable> {
-    let exports = lua.create_table()?;
-    exports.set(
-        "case",
-        LuaFunction::wrap_raw::<_, (Chunk, Case, Locale, StyleGuide, StyleOptions)>(case),
-    )?;
-    exports.set(
-        "titlecase",
-        LuaFunction::wrap_raw::<_, (Chunk, Locale, StyleGuide, StyleOptions)>(titlecase),
-    )?;
-    exports.set(
-        "lowercase",
-        LuaFunction::wrap_raw::<_, (Chunk, Locale)>(lowercase),
-    )?;
-    exports.set(
-        "uppercase",
-        LuaFunction::wrap_raw::<_, (Chunk, Locale)>(uppercase),
-    )?;
-    exports.set(
-        "sentencecase",
-        LuaFunction::wrap_raw::<_, (Chunk, Locale)>(sentencecase),
-    )?;
-    let mt = lua.create_table()?;
-    let decasify = lua.create_function(
-        move |_,
-              (_, chunk, case_, locale, styleguide, opts): (
-            LuaTable,
-            Chunk,
-            Case,
-            Locale,
-            StyleGuide,
-            Option<StyleOptions>,
-        )| {
-            Ok(case(
-                chunk,
-                case_,
-                locale,
-                styleguide,
-                opts.unwrap_or_default(),
-            ))
-        },
-    )?;
-    mt.set("__call", decasify)?;
-    exports.set_metatable(Some(mt))?;
-    let version = option_env!("VERGEN_GIT_DESCRIBE").unwrap_or_else(|| env!("CARGO_PKG_VERSION"));
-    let version = lua.create_string(version)?;
-    exports.set("version", version)?;
-    Ok(exports)
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
-impl FromLua for Chunk {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        match value {
-            LuaValue::String(s) => Ok(s.to_string_lossy().into()),
-            _ => Ok("".into()),
-        }
-    }
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
-impl FromLua for Locale {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        match value {
-            LuaValue::String(s) => Ok(s.to_string_lossy().into()),
-            LuaValue::Nil => Ok(Self::default()),
-            _ => unimplemented!(),
-        }
-    }
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
-impl FromLua for Case {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        match value {
-            LuaValue::String(s) => Ok(s.to_string_lossy().into()),
-            LuaValue::Nil => Ok(Self::default()),
-            _ => unimplemented!(),
-        }
-    }
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
-impl FromLua for StyleGuide {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        match value {
-            LuaValue::String(s) => Ok(s.to_string_lossy().into()),
-            LuaValue::Nil => Ok(Self::default()),
-            _ => unimplemented!(),
-        }
-    }
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "luamodule")))]
-impl FromLua for StyleOptions {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        match value {
-            LuaValue::Table(t) => {
-                let mut builder = StyleOptionsBuilder::new();
-                if let Ok(overrides_table) = t.get::<LuaTable>("overrides") {
-                    let overrides: Vec<Word> = overrides_table
-                        .sequence_values::<String>()
-                        .collect::<LuaResult<Vec<_>>>()?
-                        .into_iter()
-                        .map(|s| s.into())
-                        .collect();
-                    builder = builder.overrides(overrides);
-                }
-                Ok(builder.build())
-            }
-            LuaValue::Nil => Ok(Self::default()),
-            _ => unimplemented!(),
-        }
-    }
-}