refactor(parser): simplify date string parsing logic

Replace regex-based parsing with direct string manipulation for better readability and maintainability. The new implementation uses helper functions to parse date and time components separately.

Author: ldm0

rrule/src/parser/regex.rs

@@ -1,11 +1,29 @@
-//! Utility functions around the regexes we use for parsing rrule strings.
+//! Utility functions we use for parsing rrule strings.
 
-use std::{str::FromStr, sync::OnceLock};
-
-use regex::{Captures, Regex};
+use std::str::FromStr;
 
 use super::{content_line::PropertyName, ParseError};
 
+fn parse_yyyymmdd(val: &str) -> Option<(i32, u32, u32)> {
+    if val.len() != 8 {
+        return None;
+    }
+    let year = val[0..4].parse().ok()?;
+    let month = val[4..6].parse().ok()?;
+    let day = val[6..8].parse().ok()?;
+    Some((year, month, day))
+}
+
+fn parse_hhmmss(val: &str) -> Option<(u32, u32, u32)> {
+    if val.len() != 6 {
+        return None;
+    }
+    let hour = val[0..2].parse().ok()?;
+    let min = val[2..4].parse().ok()?;
+    let sec = val[4..6].parse().ok()?;
+    Some((hour, min, sec))
+}
+
 #[derive(Debug, PartialEq)]
 pub(crate) struct ParsedDateString {
     pub year: i32,
@@ -27,53 +45,36 @@ pub(crate) struct ParsedDateStringTime {
     pub sec: u32,
 }
 
-fn get_datetime_captures<T: FromStr>(
-    captures: &Captures,
-    idx: usize,
-    val: &str,
-) -> Result<T, ParseError> {
-    captures
-        .get(idx)
-        .ok_or_else(|| ParseError::InvalidDateTimeFormat(val.into()))?
-        .as_str()
-        .parse()
-        .map_err(|_| ParseError::InvalidDateTimeFormat(val.into()))
-}
-
 impl ParsedDateString {
     /// Parses a date string with format `YYYYMMDD(THHMMSSZ)` where the part in parentheses
     /// is optional. It returns [`ParsedDateString`].
     pub(crate) fn from_ical_datetime(val: &str) -> Result<Self, ParseError> {
-        static DATESTR_RE: OnceLock<Regex> = OnceLock::new();
-
-        let captures = DATESTR_RE
-            .get_or_init(|| {
-                Regex::new(
-                    r"(?m)^([0-9]{4})([0-9]{2})([0-9]{2})(T([0-9]{2})([0-9]{2})([0-9]{2})(Z?))?$",
-                )
-                .expect("DATESTR_RE must compile")
-            })
-            .captures(val)
+        let (date_part, time_part) = if val.len() >= 8 {
+            val.split_at(8)
+        } else {
+            return Err(ParseError::InvalidDateTimeFormat(val.into()));
+        };
+
+        let (year, month, day) = parse_yyyymmdd(date_part)
             .ok_or_else(|| ParseError::InvalidDateTimeFormat(val.into()))?;
 
-        let year = get_datetime_captures(&captures, 1, val)?;
-        let month = get_datetime_captures(&captures, 2, val)?;
-        let day = get_datetime_captures(&captures, 3, val)?;
+        let mut zulu_timezone_set = false;
+        let time = if !time_part.is_empty() {
+            let Some(time_part) = time_part.strip_prefix('T') else {
+                return Err(ParseError::InvalidDateTimeFormat(val.into()));
+            };
+            let time_part = time_part
+                .strip_suffix('Z')
+                .inspect(|_| zulu_timezone_set = true)
+                .unwrap_or(time_part);
 
-        // Check if time part is captured
-        let time = if captures.get(4).is_some() {
-            let hour = get_datetime_captures(&captures, 5, val)?;
-            let min = get_datetime_captures(&captures, 6, val)?;
-            let sec = get_datetime_captures(&captures, 7, val)?;
+            let (hour, min, sec) = parse_hhmmss(time_part)
+                .ok_or_else(|| ParseError::InvalidDateTimeFormat(val.into()))?;
             Some(ParsedDateStringTime { hour, min, sec })
         } else {
             None
         };
 
-        let zulu_timezone_set = match captures.get(8) {
-            Some(part) => part.as_str() == "Z",
-            None => false,
-        };
         let flags = ParsedDateStringFlags { zulu_timezone_set };
 
         Ok(Self {
@@ -89,10 +90,12 @@ impl ParsedDateString {
 /// Get the line property name, the `RRULE:`, `EXRULE:` etc part.
 pub(crate) fn get_property_name(val: &str) -> Result<Option<PropertyName>, ParseError> {
     val.chars()
-       .position(|c| c == ':' || c == ';')
-       .map(|pos| &val[0..pos])
-       .filter(|candidate| candidate.chars().all(|c| c.is_ascii_alphabetic()))
-       .map_or(Ok(None), |candidate| PropertyName::from_str(candidate).map(Some))
+        .position(|c| c == ':' || c == ';')
+        .map(|pos| &val[0..pos])
+        .filter(|candidate| candidate.chars().all(|c| c.is_ascii_alphabetic()))
+        .map_or(Ok(None), |candidate| {
+            PropertyName::from_str(candidate).map(Some)
+        })
 }
 
 #[cfg(test)]