fix: invalid timezone should return err not panic

src/lib.rs

@@ -715,7 +715,8 @@ impl Parser {
     ) -> ParseResult<(NaiveDateTime, Option<FixedOffset>, Option<Vec<String>>)> {
         let default_date = default.unwrap_or(&Local::now().naive_local()).date();
 
-        let default_ts = NaiveDateTime::new(default_date, NaiveTime::from_hms_opt(0, 0, 0).unwrap());
+        let default_ts =
+            NaiveDateTime::new(default_date, NaiveTime::from_hms_opt(0, 0, 0).unwrap());
 
         let (res, tokens) =
             self.parse_with_tokens(timestr, dayfirst, yearfirst, fuzzy, fuzzy_with_tokens)?;
@@ -853,7 +854,12 @@ impl Parser {
                 } else if i + 2 < len_l && l[i + 2] == ":" {
                     // -03:00
                     hour_offset = Some(l[i + 1].parse::<i32>()?);
-                    min_offset = Some(l[i + 3].parse::<i32>()?);
+                    // if timezone is wrong format like "-03:" just return a Err, should not panic.
+                    min_offset = if i + 3 > l.len() - 1 {
+                        return Err(ParseError::TimezoneUnsupported);
+                    } else {
+                        Some(l[i + 3].parse::<i32>()?)
+                    };
                     i += 2;
                 } else if len_li <= 2 {
                     // -[0]3
@@ -979,9 +985,9 @@ impl Parser {
         let hour = res.hour.unwrap_or(default.hour() as i32) as u32;
         let minute = res.minute.unwrap_or(default.minute() as i32) as u32;
         let second = res.second.unwrap_or(default.second() as i32) as u32;
-        let nanosecond = res
+        let nanosecond =
-            .nanosecond
+            res.nanosecond
-            .unwrap_or(default.timestamp_subsec_nanos() as i64) as u32;
+                .unwrap_or(default.and_utc().timestamp_subsec_nanos() as i64) as u32;
         let t =
             NaiveTime::from_hms_nano_opt(hour, minute, second, nanosecond).ok_or_else(|| {
                 if hour >= 24 {
@@ -1155,7 +1161,10 @@ impl Parser {
                 idx += 1;
             } else {
                 //let value = value.floor().to_i32().ok_or(Err(ParseError::InvalidNumeric()))
-                let value = value.floor().to_i32().ok_or_else(|| ParseError::InvalidNumeric(value_repr.to_owned()))?;
+                let value = value
+                    .floor()
+                    .to_i32()
+                    .ok_or_else(|| ParseError::InvalidNumeric(value_repr.to_owned()))?;
                 ymd.append(value, &value_repr, None)?;
             }
 

src/tests/fuzzing.rs

@@ -1,5 +1,5 @@
-use base64::Engine;
 use base64::engine::general_purpose::STANDARD;
+use base64::Engine;
 use chrono::NaiveDate;
 use std::collections::HashMap;
 use std::str;
@@ -21,7 +21,10 @@ fn test_fuzz() {
         Err(ParseError::UnrecognizedFormat)
     );
 
-    let default = NaiveDate::from_ymd_opt(2016, 6, 29).unwrap().and_hms_opt(0, 0, 0).unwrap();
+    let default = NaiveDate::from_ymd_opt(2016, 6, 29)
+        .unwrap()
+        .and_hms_opt(0, 0, 0)
+        .unwrap();
     let p = Parser::default();
     let res = p.parse(
         "\x0D\x31",
@@ -66,12 +69,20 @@ fn empty_string() {
 
 #[test]
 fn github_33() {
-    assert_eq!(parse("66:'"), Err(ParseError::InvalidNumeric("'".to_owned())))
+    assert_eq!(
+        parse("66:'"),
+        Err(ParseError::InvalidNumeric("'".to_owned()))
+    )
 }
 
 #[test]
 fn github_32() {
-    assert_eq!(parse("99999999999999999999999"), Err(ParseError::InvalidNumeric("99999999999999999999999".to_owned())))
+    assert_eq!(
+        parse("99999999999999999999999"),
+        Err(ParseError::InvalidNumeric(
+            "99999999999999999999999".to_owned()
+        ))
+    )
 }
 
 #[test]
@@ -97,3 +108,9 @@ fn github_36() {
     let parse_result = parse(parse_str);
     assert!(parse_result.is_err());
 }
+
+#[test]
+fn github_46() {
+    let parse_result = parse("2000-01-01 12:00:00+00:");
+    assert!(parse_result.is_err());
+}

src/tests/mod.rs

@@ -2,13 +2,19 @@ mod fuzzing;
 mod pycompat_parser;
 mod pycompat_tokenizer;
 
-use chrono::NaiveDate;
 use crate::parse;
+use chrono::NaiveDate;
 
 #[test]
 fn nanosecond_precision() {
     assert_eq!(
         parse("2008.12.29T08:09:10.123456789").unwrap(),
-        (NaiveDate::from_ymd_opt(2008, 12, 29).unwrap().and_hms_nano_opt(8, 9, 10, 123_456_789).unwrap(), None)
+        (
+            NaiveDate::from_ymd_opt(2008, 12, 29)
+                .unwrap()
+                .and_hms_nano_opt(8, 9, 10, 123_456_789)
+                .unwrap(),
+            None
+        )
     )
 }