dxr: simplify datetime parser logic

Author: decathorpe

dxr/src/error.rs

@@ -5,6 +5,7 @@ use thiserror::Error;
 use crate::fault::Fault;
 
 #[derive(Debug, Error, PartialEq)]
+#[non_exhaustive]
 /// Error type representing conversion errors between XML-RPC values and Rust values.
 pub enum DxrError {
     /// Error variant for XML parser errors.
@@ -13,6 +14,12 @@ pub enum DxrError {
         /// description of the parsing error
         error: String,
     },
+    /// Error variant for invalid dateTime.iso8601 values.
+    #[error("Invalid format for dateTime.iso8601 value: \n{}", .error)]
+    InvalidDateTime {
+        /// description of the parsing error
+        error: String,
+    },
     /// Error variant for a missing struct field.
     #[error("Struct '{}' missing field: {}", .name, .field)]
     MissingField {
@@ -61,6 +68,27 @@ impl DxrError {
         }
     }
 
+    /// Construct an [`DxrError`] for invalid datetime values.
+    pub fn invalid_datetime(error: String) -> DxrError {
+        DxrError::InvalidDateTime { error }
+    }
+
+    /// Check if a given [`DxrError`] was raised for an invalid datetime value.
+    pub fn is_invalid_datetime(&self) -> bool {
+        matches!(self, DxrError::InvalidDateTime { .. })
+    }
+
+    /// Check for [`DxrError::InvalidDateTime`] and return the inner error in case of a match.
+    ///
+    /// The returned string describes the parsing failure.
+    pub fn as_invalid_datetime(&self) -> Option<&str> {
+        if let DxrError::InvalidDateTime { error } = self {
+            Some(error)
+        } else {
+            None
+        }
+    }
+
     /// Construct a [`DxrError`] for a missing struct field.
     pub fn missing_field(name: &'static str, field: &'static str) -> DxrError {
         DxrError::MissingField {
@@ -133,11 +161,6 @@ impl DxrError {
 
 impl From<DxrError> for Fault {
     fn from(error: DxrError) -> Self {
-        match error {
-            DxrError::InvalidData { .. } => Fault::new(400, error.to_string()),
-            DxrError::MissingField { .. } => Fault::new(400, error.to_string()),
-            DxrError::ParameterMismatch { .. } => Fault::new(400, error.to_string()),
-            DxrError::WrongType { .. } => Fault::new(400, error.to_string()),
-        }
+        Fault::new(400, error.to_string())
     }
 }

dxr/src/tests/xml/values.rs

@@ -182,10 +182,10 @@ fn from_datetime() {
 #[test]
 fn from_datetime_fail() {
     let value = "<value><dateTime.iso8601>202520252025</dateTime.iso8601></value>";
-    assert!(from_str::<Value>(value)
+    assert!(dbg!(from_str::<Value>(value))
         .unwrap_err()
         .to_string()
-        .contains("Invalid dateTime.iso8601 value"));
+        .contains("Invalid format for dateTime.iso8601 value"));
 }
 
 #[test]

dxr/src/values.rs

@@ -1,6 +1,5 @@
 mod datetime;
 pub use datetime::DateTime;
-pub use datetime::DateTimeParseError;
 
 mod ser_de;
 

dxr/src/values/datetime.rs

@@ -7,6 +7,8 @@ use winnow::error::{ContextError, StrContext, StrContextValue};
 use winnow::token::take;
 use winnow::Parser;
 
+use crate::error::DxrError;
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct DateTime {
     year: u16,
@@ -55,31 +57,15 @@ impl Display for DateTime {
 }
 
 impl FromStr for DateTime {
-    type Err = DateTimeParseError;
+    type Err = DxrError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         DateTimeParser
             .parse(s)
-            .map_err(|e| DateTimeParseError::InvalidFormat(e.to_string()))
+            .map_err(|e| DxrError::invalid_datetime(e.to_string()))
     }
 }
 
-#[derive(Clone, Debug, thiserror::Error)]
-pub enum DateTimeParseError {
-    #[error("Invalid format for dateTime.iso8601 value: {}", .0)]
-    InvalidFormat(String),
-    #[error("Invalid dateTime.iso8601 value: Month out of range ({})", .0)]
-    InvalidMonth(u8),
-    #[error("Invalid dateTime.iso8601 value: Day out of range ({})", .0)]
-    InvalidDay(u8),
-    #[error("Invalid dateTime.iso8601 value: Hour out of range ({})", .0)]
-    InvalidHour(u8),
-    #[error("Invalid dateTime.iso8601 value: Minutes out of range ({})", .0)]
-    InvalidMinutes(u8),
-    #[error("Invalid dateTime.iso8601 value: Seconds out of range ({})", .0)]
-    InvalidSeconds(u8),
-}
-
 struct DateTimeParser;
 
 impl Parser<&str, DateTime, ContextError> for DateTimeParser {
@@ -127,10 +113,7 @@ impl Parser<&str, u8, ContextError> for MonthParser {
     fn parse_next(&mut self, input: &mut &str) -> winnow::Result<u8> {
         take(2usize)
             .parse_to()
-            .try_map(|month| match month {
-                1..=12 => Ok(month),
-                _ => Err(DateTimeParseError::InvalidMonth(month)),
-            })
+            .verify(|m| *m > 0 && *m <= 12)
             .context(StrContext::Label("month"))
             .parse_next(input)
     }
@@ -144,13 +127,7 @@ impl Parser<&str, u8, ContextError> for DayParser {
     fn parse_next(&mut self, input: &mut &str) -> winnow::Result<u8> {
         take(2usize)
             .parse_to()
-            .try_map(|day| {
-                if day == 0 || day > self.max {
-                    Err(DateTimeParseError::InvalidDay(day))
-                } else {
-                    Ok(day)
-                }
-            })
+            .verify(|d| *d > 0 && *d <= self.max)
             .context(StrContext::Label("day"))
             .parse_next(input)
     }
@@ -162,13 +139,7 @@ impl Parser<&str, u8, ContextError> for HourParser {
     fn parse_next(&mut self, input: &mut &str) -> winnow::Result<u8> {
         take(2usize)
             .parse_to()
-            .try_map(|hour| {
-                if hour > 24 {
-                    Err(DateTimeParseError::InvalidHour(hour))
-                } else {
-                    Ok(hour)
-                }
-            })
+            .verify(|h| *h < 24)
             .context(StrContext::Label("hour"))
             .parse_next(input)
     }
@@ -180,13 +151,7 @@ impl Parser<&str, u8, ContextError> for MinuteParser {
     fn parse_next(&mut self, input: &mut &str) -> winnow::Result<u8> {
         take(2usize)
             .parse_to()
-            .try_map(|minute| {
-                if minute > 59 {
-                    Err(DateTimeParseError::InvalidMinutes(minute))
-                } else {
-                    Ok(minute)
-                }
-            })
+            .verify(|m| *m < 60)
             .context(StrContext::Label("minute"))
             .parse_next(input)
     }
@@ -198,13 +163,7 @@ impl Parser<&str, u8, ContextError> for SecondParser {
     fn parse_next(&mut self, input: &mut &str) -> winnow::Result<u8> {
         take(2usize)
             .parse_to()
-            .try_map(|second| {
-                if second > 59 {
-                    Err(DateTimeParseError::InvalidSeconds(second))
-                } else {
-                    Ok(second)
-                }
-            })
+            .verify(|s| *s < 60)
             .context(StrContext::Label("second"))
             .parse_next(input)
     }