Merge pull request #15 from rracariu/update-deps-add-default

Update dependencies and fix some issues uncover by newer lint rules

Author: hecsalazarf

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "libhaystack"
-version = "1.0.10"
+version = "1.0.11"
 description = "Rust implementation of the Haystack 4 data types, defs, filter, units, and encodings"
 authors = ["J2 Innovations", "Radu Racariu <[email protected]>"]
 edition = "2021"

Cargo.toml

@@ -26,7 +26,7 @@ use std::os::raw::c_char;
 /// ```
 #[no_mangle]
 pub extern "C" fn haystack_value_init() -> Box<Value> {
-    Box::new(Value::default())
+    Box::<Value>::default()
 }
 
 /// Destructs and free a [Value](crate::val::Value)

src/c_api/value.rs

@@ -695,7 +695,6 @@ impl<'a> Namespace<'a> {
     pub fn protos(&'a self, parent: &Dict) -> Vec<Dict> {
         parent
             .keys()
-            .into_iter()
             .map(|name| self.protos_from_def(parent, name))
             .fold(Vec::new(), |mut vec, cur| {
                 vec.extend(cur);

src/haystack/defs/namespace.rs

@@ -277,7 +277,7 @@ pub(crate) fn parse_number_date_time<R: Read>(
         let mut read_count = 0;
         let mut cur = scanner.cur;
         for _ in 0..4 {
-            if !(b'0'..=b'9').contains(&cur) || scanner.is_eof {
+            if !cur.is_ascii_digit() || scanner.is_eof {
                 break;
             }
             read_count += 1;

src/haystack/encoding/zinc/decode/lexer.rs

@@ -99,21 +99,27 @@ pub(crate) fn parse_datetime<R: Read>(scanner: &mut Scanner<R>) -> Result<DateTi
     if tz == "UTC" {
         Ok(utc.into())
     } else {
-        match fixed_offset {
-            Some(fixed_offset) => {
-                let fixed = fixed_offset
-                    .ymd(date.year(), date.month(), date.day())
-                    .and_hms_nano(time.hour(), time.minute(), time.second(), time.nanosecond());
-                match make_date_time_with_tz(&fixed, &tz) {
-                    Ok(datetime) => Ok(datetime.into()),
-                    Err(err) => scanner.make_generic_err(&err),
-                }
-            }
-            None => match make_date_time_with_tz(&utc.with_timezone(&Utc.fix()), &tz) {
-                Ok(datetime) => Ok(datetime.into()),
-                Err(err) => scanner.make_generic_err(&err),
-            },
-        }
+        fixed_offset
+            .map_or_else(
+                || make_date_time_with_tz(&utc.with_timezone(&Utc.fix()), &tz),
+                |offset| {
+                    offset
+                        .with_ymd_and_hms(
+                            date.year(),
+                            date.month(),
+                            date.day(),
+                            time.hour(),
+                            time.minute(),
+                            time.second(),
+                        )
+                        .single()
+                        .and_then(|dt| dt.with_nanosecond(time.nanosecond()))
+                        .ok_or_else(|| String::from("Invalid date time."))
+                        .and_then(|fixed| make_date_time_with_tz(&fixed, &tz))
+                },
+            )
+            .map(DateTime::from)
+            .or_else(|err| scanner.make_generic_err(&err))
     }
 }
 
@@ -123,7 +129,7 @@ fn parse_time_zone<R: Read>(
     if scanner.cur == b'Z' {
         if scanner.safe_peek() == Some(b' ')
             && if let Some(char) = scanner.safe_peek() {
-                (b'A'..=b'Z').contains(&char)
+                char.is_ascii_uppercase()
             } else {
                 false
             }
@@ -158,12 +164,12 @@ fn parse_time_zone<R: Read>(
         let tz_name = parse_time_zone_name(scanner)?;
 
         let fixed_offset = if gmt_sign == "+" {
-            FixedOffset::east(dur.num_seconds() as i32)
+            FixedOffset::east_opt(dur.num_seconds() as i32)
         } else {
-            FixedOffset::west(dur.num_seconds() as i32)
+            FixedOffset::west_opt(dur.num_seconds() as i32)
         };
 
-        Ok((tz_name, Some(fixed_offset)))
+        Ok((tz_name, fixed_offset))
     }
 }
 

src/haystack/encoding/zinc/decode/scalar/date_time.rs

@@ -18,7 +18,7 @@ pub(crate) fn parse_number<R: Read>(scanner: &mut Scanner<R>) -> Result<Number,
 
     if !scanner.is_eof && scanner.is_any_of("eE") {
         let next = scanner.peek()?;
-        if next == b'+' || next == b'-' || (b'0'..=b'9').contains(&next) {
+        if next == b'+' || next == b'-' || next.is_ascii_digit() {
             exponent = Some(parse_exponent(scanner)?);
         }
     }

src/haystack/encoding/zinc/decode/scalar/number.rs

@@ -97,22 +97,22 @@ impl<'a, R: Read> Scanner<'a, R> {
 
     /// True if cur is a digit char
     pub fn is_digit(&self) -> bool {
-        (b'0'..=b'9').contains(&self.cur)
+        self.cur.is_ascii_digit()
     }
 
     /// True if cur is a hex digit char
     pub fn is_hex_digit(&self) -> bool {
-        self.is_digit() || (b'a'..=b'f').contains(&self.cur) || (b'A'..=b'F').contains(&self.cur)
+        self.cur.is_ascii_hexdigit()
     }
 
     /// True if cur is an upper case char
     pub fn is_upper(&self) -> bool {
-        (b'A'..=b'Z').contains(&self.cur)
+        self.cur.is_ascii_uppercase()
     }
 
     /// True if cur is an lower case char
     pub fn is_lower(&self) -> bool {
-        (b'a'..=b'z').contains(&self.cur)
+        self.cur.is_ascii_lowercase()
     }
 
     /// True if cur is an alpha char

src/haystack/encoding/zinc/decode/scanner.rs

@@ -28,7 +28,7 @@ use crate::haystack::val::Value;
 /// assert!(!Bool::try_from(&false_val).unwrap().value)
 ///```
 ///
-#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Copy, Clone, Debug)]
+#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Copy, Clone, Debug, Default)]
 pub struct Bool {
     pub value: bool,
 }

src/haystack/val/boolean.rs

@@ -25,7 +25,7 @@ use std::{
 /// assert_eq!(Coord::try_from(&coord).unwrap().lat, 45.0);
 ///```
 ///
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Default)]
 pub struct Coord {
     pub lat: f64,
     pub long: f64,