Simplify and always pass an Option<&Locale>.

endoli · Oct 15, 2023 · eaf1250 · eaf1250
1 parent 48e6089
commit eaf1250
Show file tree

Hide file tree

Showing 3 changed files with 33 additions and 49 deletions.
diff --git a/src/boolean.rs b/src/boolean.rs
@@ -30,12 +30,18 @@
 use crate::Parse;
 use icu_locid::{locale, Locale};
 
-fn locale_matches(left: &Locale, right: &Locale) -> bool {
-    (*left == *right) || (*left == Locale::UND) || (*right == Locale::UND)
+fn locale_matches(left: Option<&Locale>, right: &Locale) -> bool {
+    if *right == Locale::UND {
+        true
+    } else if let Some(left) = left {
+        *left == *right
+    } else {
+        true
+    }
 }
 
 impl Parse for bool {
-    fn parse(text: &str, locale: &Locale) -> Option<bool> {
+    fn parse(text: &str, locale: Option<&Locale>) -> Option<bool> {
         let en = locale!("en");
         match &*text.to_lowercase() {
             "1" => Some(true),
@@ -51,29 +57,29 @@ impl Parse for bool {
 
 #[cfg(test)]
 mod tests {
-    use crate::{parse, parse_with_locale};
+    use crate::parse;
     use icu_locid::locale;
 
     #[test]
     fn basic() {
-        assert_eq!(Some(true), parse::<bool>("1"));
-        assert_eq!(Some(true), parse::<bool>("ok"));
-        assert_eq!(Some(true), parse::<bool>("okay"));
-        assert_eq!(Some(true), parse::<bool>("on"));
-        assert_eq!(Some(true), parse::<bool>("true"));
-        assert_eq!(Some(true), parse::<bool>("yep"));
-        assert_eq!(Some(true), parse::<bool>("yes"));
+        assert_eq!(Some(true), parse::<bool>("1", None));
+        assert_eq!(Some(true), parse::<bool>("ok", None));
+        assert_eq!(Some(true), parse::<bool>("okay", None));
+        assert_eq!(Some(true), parse::<bool>("on", None));
+        assert_eq!(Some(true), parse::<bool>("true", None));
+        assert_eq!(Some(true), parse::<bool>("yep", None));
+        assert_eq!(Some(true), parse::<bool>("yes", None));
 
-        assert_eq!(Some(false), parse::<bool>("0"));
-        assert_eq!(Some(false), parse::<bool>("false"));
-        assert_eq!(Some(false), parse::<bool>("no"));
-        assert_eq!(Some(false), parse::<bool>("nope"));
-        assert_eq!(Some(false), parse::<bool>("off"));
+        assert_eq!(Some(false), parse::<bool>("0", None));
+        assert_eq!(Some(false), parse::<bool>("false", None));
+        assert_eq!(Some(false), parse::<bool>("no", None));
+        assert_eq!(Some(false), parse::<bool>("nope", None));
+        assert_eq!(Some(false), parse::<bool>("off", None));
 
         let bad_locale = locale!("no");
-        assert_eq!(Some(true), parse_with_locale::<bool>("1", &bad_locale));
-        assert_eq!(Some(false), parse_with_locale::<bool>("0", &bad_locale));
-        assert_eq!(None, parse_with_locale::<bool>("okay", &bad_locale));
-        assert_eq!(None, parse_with_locale::<bool>("nope", &bad_locale));
+        assert_eq!(Some(true), parse::<bool>("1", Some(&bad_locale)));
+        assert_eq!(Some(false), parse::<bool>("0", Some(&bad_locale)));
+        assert_eq!(None, parse::<bool>("okay", Some(&bad_locale)));
+        assert_eq!(None, parse::<bool>("nope", Some(&bad_locale)));
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -32,7 +32,7 @@
 //! `"yes"`, `"no"` or perhaps even `"nope"`.
 //!
 //! ```
-//! let enabled = humanize::parse_or::<bool>("on", false);
+//! let enabled = humanize::parse_or::<bool>("on", None, false);
 //! assert_eq!(enabled, true);
 //! ```
 //!
@@ -56,4 +56,4 @@
 pub mod boolean;
 mod parser;
 
-pub use crate::parser::{parse, parse_or, parse_with_locale, parse_with_locale_or, Parse};
+pub use crate::parser::{parse, parse_or, Parse};
diff --git a/src/parser.rs b/src/parser.rs
@@ -9,38 +9,16 @@ use icu_locid::Locale;
 /// Construct `Self` by parsing humanized text.
 pub trait Parse: Sized {
     /// Perform the conversion.
-    fn parse(text: &str, locale: &Locale) -> Option<Self>;
+    fn parse(text: &str, locale: Option<&Locale>) -> Option<Self>;
 }
 
 /// Construct a value by parsing humanized text.
-///
-/// This uses a wild card for the locale, so text in any locale
-/// supported by the library should work.
-pub fn parse<T: Parse>(text: &str) -> Option<T> {
-    let locale = Locale::default();
-    T::parse(text, &locale)
+pub fn parse<T: Parse>(text: &str, locale: Option<&Locale>) -> Option<T> {
+    T::parse(text, locale)
 }
 
 /// Construct a value by parsing humanized `text`, with a `default`
 /// value when parsing fails.
-///
-/// This uses a wild card for the locale, so text in any locale
-/// supported by the library should work.
-pub fn parse_or<T: Parse>(text: &str, default: T) -> T {
-    parse::<T>(text).unwrap_or(default)
-}
-
-/// Construct a value by parsing humanized `text` using the specified [`locale`].
-///
-/// [`locale`]: Locale
-pub fn parse_with_locale<T: Parse>(text: &str, locale: &Locale) -> Option<T> {
-    T::parse(text, locale)
-}
-
-/// Construct a value by parsing humanized `text` using the specified [`locale`],
-/// with a `default` value when parsing fails.
-///
-/// [`locale`]: Locale
-pub fn parse_with_locale_or<T: Parse>(text: &str, locale: &Locale, default: T) -> T {
-    T::parse(text, locale).unwrap_or(default)
+pub fn parse_or<T: Parse>(text: &str, locale: Option<&Locale>, default: T) -> T {
+    parse::<T>(text, locale).unwrap_or(default)
 }