Make creating a SrtftimeItems return a Result

src/date.rs

@@ -21,6 +21,7 @@ use crate::naive::{IsoWeek, NaiveDate, NaiveTime};
 use crate::offset::{TimeZone, Utc};
 use crate::time_delta::TimeDelta;
 use crate::DateTime;
+use crate::ParseError;
 use crate::{Datelike, Weekday};
 
 /// ISO 8601 calendar date with time zone.
@@ -329,8 +330,8 @@ where
     #[cfg(any(feature = "alloc", feature = "std", test))]
     #[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "std"))))]
     #[inline]
-    pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
-        self.format_with_items(StrftimeItems::new(fmt))
+    pub fn format<'a>(&self, fmt: &'a str) -> Result<DelayedFormat<StrftimeItems<'a>>, ParseError> {
+        Ok(self.format_with_items(StrftimeItems::new(fmt)?))
     }
 
     /// Formats the date with the specified formatting items and locale.
@@ -365,8 +366,8 @@ where
         &self,
         fmt: &'a str,
         locale: Locale,
-    ) -> DelayedFormat<StrftimeItems<'a>> {
-        self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale), locale)
+    ) -> Result<DelayedFormat<StrftimeItems<'a>>, ParseError> {
+        Ok(self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale)?, locale))
     }
 }
 

src/datetime/mod.rs

@@ -578,7 +578,7 @@ impl DateTime<FixedOffset> {
     /// ```
     pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<DateTime<FixedOffset>> {
         let mut parsed = Parsed::new();
-        parse(&mut parsed, s, StrftimeItems::new(fmt))?;
+        parse(&mut parsed, s, StrftimeItems::new(fmt)?)?;
         parsed.to_datetime()
     }
 }
@@ -753,14 +753,14 @@ where
     /// use chrono::prelude::*;
     ///
     /// let date_time: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 04, 02, 12, 50, 32).unwrap();
-    /// let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
+    /// let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M").unwrap());
     /// assert_eq!(formatted, "02/04/2017 12:50");
     /// ```
     #[cfg(any(feature = "alloc", feature = "std", test))]
     #[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "std"))))]
     #[inline]
-    pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
-        self.format_with_items(StrftimeItems::new(fmt))
+    pub fn format<'a>(&self, fmt: &'a str) -> Result<DelayedFormat<StrftimeItems<'a>>, ParseError> {
+        Ok(self.format_with_items(StrftimeItems::new(fmt)?))
     }
 
     /// Formats the combined date and time with the specified formatting items and locale.
@@ -798,8 +798,8 @@ where
         &self,
         fmt: &'a str,
         locale: Locale,
-    ) -> DelayedFormat<StrftimeItems<'a>> {
-        self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale), locale)
+    ) -> Result<DelayedFormat<StrftimeItems<'a>>, ParseError> {
+        Ok(self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale)?, locale))
     }
 }
 
@@ -1331,3 +1331,8 @@ fn test_decodable_json<FUtc, FFixed, FLocal, E>(
     assert!(utc_from_str(r#""2014-07-32T12:34:06Z""#).is_err());
     assert!(fixed_from_str(r#""2014-07-32T12:34:06Z""#).is_err());
 }
+
+#[test]
+fn test_invalid_format() {
+    assert!(Utc::now().format("%").is_err());
+}

src/datetime/tests.rs

@@ -388,7 +388,10 @@ fn test_to_string_round_trip_with_local() {
 fn test_datetime_format_with_local() {
     // if we are not around the year boundary, local and UTC date should have the same year
     let dt = Local::now().with_month(5).unwrap();
-    assert_eq!(dt.format("%Y").to_string(), dt.with_timezone(&Utc).format("%Y").to_string());
+    assert_eq!(
+        dt.format("%Y").unwrap().to_string(),
+        dt.with_timezone(&Utc).format("%Y").unwrap().to_string()
+    );
 }
 
 #[test]
@@ -579,25 +582,25 @@ fn test_datetime_format_alignment() {
     let datetime = Utc.with_ymd_and_hms(2007, 1, 2, 0, 0, 0).unwrap();
 
     // Item::Literal
-    let percent = datetime.format("%%");
+    let percent = datetime.format("%%").unwrap();
     assert_eq!("  %", format!("{:>3}", percent));
     assert_eq!("%  ", format!("{:<3}", percent));
     assert_eq!(" % ", format!("{:^3}", percent));
 
     // Item::Numeric
-    let year = datetime.format("%Y");
+    let year = datetime.format("%Y").unwrap();
     assert_eq!("  2007", format!("{:>6}", year));
     assert_eq!("2007  ", format!("{:<6}", year));
     assert_eq!(" 2007 ", format!("{:^6}", year));
 
     // Item::Fixed
-    let tz = datetime.format("%Z");
+    let tz = datetime.format("%Z").unwrap();
     assert_eq!("  UTC", format!("{:>5}", tz));
     assert_eq!("UTC  ", format!("{:<5}", tz));
     assert_eq!(" UTC ", format!("{:^5}", tz));
 
     // [Item::Numeric, Item::Space, Item::Literal, Item::Space, Item::Numeric]
-    let ymd = datetime.format("%Y %B %d");
+    let ymd = datetime.format("%Y %B %d").unwrap();
     let ymd_formatted = "2007 January 02";
     assert_eq!(format!("  {}", ymd_formatted), format!("{:>17}", ymd));
     assert_eq!(format!("{}  ", ymd_formatted), format!("{:<17}", ymd));

src/format/mod.rs

@@ -22,7 +22,7 @@
 //!
 //! let date_time = Utc.with_ymd_and_hms(2020, 11, 10, 0, 1, 32).unwrap();
 //!
-//! let formatted = format!("{}", date_time.format("%Y-%m-%d %H:%M:%S"));
+//! let formatted = format!("{}", date_time.format("%Y-%m-%d %H:%M:%S").unwrap());
 //! assert_eq!(formatted, "2020-11-10 00:01:32");
 //!
 //! let parsed = Utc.datetime_from_str(&formatted, "%Y-%m-%d %H:%M:%S")?;

src/format/parse.rs

@@ -895,7 +895,7 @@ fn parse_rfc850() {
     let dt = Utc.with_ymd_and_hms(1994, 11, 6, 8, 49, 37).unwrap();
 
     // Check that the format is what we expect
-    assert_eq!(dt.format(RFC850_FMT).to_string(), dt_str);
+    assert_eq!(dt.format(RFC850_FMT).unwrap().to_string(), dt_str);
 
     // Check that it parses correctly
     assert_eq!(Ok(dt), Utc.datetime_from_str("Sunday, 06-Nov-94 08:49:37 GMT", RFC850_FMT));

src/format/strftime.rs

@@ -174,6 +174,8 @@ Notes:
    China Daylight Time.
 */
 
+use crate::format::{ParseError, BAD_FORMAT};
+
 #[cfg(feature = "unstable-locales")]
 extern crate alloc;
 
@@ -227,19 +229,33 @@ pub struct StrftimeItems<'a> {
 
 impl<'a> StrftimeItems<'a> {
     /// Creates a new parsing iterator from the `strftime`-like format string.
-    pub fn new(s: &'a str) -> StrftimeItems<'a> {
-        Self::with_remainer(s)
+    pub fn new(s: &'a str) -> Result<StrftimeItems<'a>, ParseError> {
+        let strftime = Self::with_remainer(s);
+        if strftime.clone().any(|i| i == Item::Error) {
+            return Err(BAD_FORMAT);
+        }
+        return Ok(strftime);
     }
 
     /// Creates a new parsing iterator from the `strftime`-like format string.
     #[cfg(feature = "unstable-locales")]
     #[cfg_attr(docsrs, doc(cfg(feature = "unstable-locales")))]
-    pub fn new_with_locale(s: &'a str, locale: Locale) -> StrftimeItems<'a> {
-        let d_fmt = StrftimeItems::new(locales::d_fmt(locale)).collect();
-        let d_t_fmt = StrftimeItems::new(locales::d_t_fmt(locale)).collect();
-        let t_fmt = StrftimeItems::new(locales::t_fmt(locale)).collect();
-
-        StrftimeItems { remainder: s, recons: Vec::new(), d_fmt, d_t_fmt, t_fmt }
+    pub fn new_with_locale(s: &'a str, locale: Locale) -> Result<StrftimeItems<'a>, ParseError> {
+        let d_fmt = StrftimeItems::new(locales::d_fmt(locale))
+            .expect("ERROR: No date format defined for given format")
+            .collect();
+        let d_t_fmt = StrftimeItems::new(locales::d_t_fmt(locale))
+            .expect("ERROR: No datetime format for the given locale")
+            .collect();
+        let t_fmt = StrftimeItems::new(locales::t_fmt(locale))
+            .expect("ERROR: No time format gor the given locale")
+            .collect();
+
+        let strftime = StrftimeItems { remainder: s, recons: Vec::new(), d_fmt, d_t_fmt, t_fmt };
+        if strftime.clone().any(|i| i == Item::Error) {
+            return Err(BAD_FORMAT);
+        }
+        return Ok(strftime);
     }
 
     #[cfg(not(feature = "unstable-locales"))]
@@ -505,9 +521,10 @@ impl<'a> Iterator for StrftimeItems<'a> {
 fn test_strftime_items() {
     fn parse_and_collect(s: &str) -> Vec<Item<'_>> {
         // map any error into `[Item::Error]`. useful for easy testing.
-        let items = StrftimeItems::new(s);
-        let items = items.map(|spec| if spec == Item::Error { None } else { Some(spec) });
-        items.collect::<Option<Vec<_>>>().unwrap_or_else(|| vec![Item::Error])
+        match StrftimeItems::new(s) {
+            Err(_) => vec![Item::Error],
+            Ok(items) => items.into_iter().collect(),
+        }
     }
 
     assert_eq!(parse_and_collect(""), []);
@@ -570,69 +587,72 @@ fn test_strftime_docs() {
         .unwrap();
 
     // date specifiers
-    assert_eq!(dt.format("%Y").to_string(), "2001");
-    assert_eq!(dt.format("%C").to_string(), "20");
-    assert_eq!(dt.format("%y").to_string(), "01");
-    assert_eq!(dt.format("%m").to_string(), "07");
-    assert_eq!(dt.format("%b").to_string(), "Jul");
-    assert_eq!(dt.format("%B").to_string(), "July");
-    assert_eq!(dt.format("%h").to_string(), "Jul");
-    assert_eq!(dt.format("%d").to_string(), "08");
-    assert_eq!(dt.format("%e").to_string(), " 8");
-    assert_eq!(dt.format("%e").to_string(), dt.format("%_d").to_string());
-    assert_eq!(dt.format("%a").to_string(), "Sun");
-    assert_eq!(dt.format("%A").to_string(), "Sunday");
-    assert_eq!(dt.format("%w").to_string(), "0");
-    assert_eq!(dt.format("%u").to_string(), "7");
-    assert_eq!(dt.format("%U").to_string(), "28");
-    assert_eq!(dt.format("%W").to_string(), "27");
-    assert_eq!(dt.format("%G").to_string(), "2001");
-    assert_eq!(dt.format("%g").to_string(), "01");
-    assert_eq!(dt.format("%V").to_string(), "27");
-    assert_eq!(dt.format("%j").to_string(), "189");
-    assert_eq!(dt.format("%D").to_string(), "07/08/01");
-    assert_eq!(dt.format("%x").to_string(), "07/08/01");
-    assert_eq!(dt.format("%F").to_string(), "2001-07-08");
-    assert_eq!(dt.format("%v").to_string(), " 8-Jul-2001");
+    assert_eq!(dt.format("%Y").unwrap().to_string(), "2001");
+    assert_eq!(dt.format("%C").unwrap().to_string(), "20");
+    assert_eq!(dt.format("%y").unwrap().to_string(), "01");
+    assert_eq!(dt.format("%m").unwrap().to_string(), "07");
+    assert_eq!(dt.format("%b").unwrap().to_string(), "Jul");
+    assert_eq!(dt.format("%B").unwrap().to_string(), "July");
+    assert_eq!(dt.format("%h").unwrap().to_string(), "Jul");
+    assert_eq!(dt.format("%d").unwrap().to_string(), "08");
+    assert_eq!(dt.format("%e").unwrap().to_string(), " 8");
+    assert_eq!(dt.format("%e").unwrap().to_string(), dt.format("%_d").unwrap().to_string());
+    assert_eq!(dt.format("%a").unwrap().to_string(), "Sun");
+    assert_eq!(dt.format("%A").unwrap().to_string(), "Sunday");
+    assert_eq!(dt.format("%w").unwrap().to_string(), "0");
+    assert_eq!(dt.format("%u").unwrap().to_string(), "7");
+    assert_eq!(dt.format("%U").unwrap().to_string(), "28");
+    assert_eq!(dt.format("%W").unwrap().to_string(), "27");
+    assert_eq!(dt.format("%G").unwrap().to_string(), "2001");
+    assert_eq!(dt.format("%g").unwrap().to_string(), "01");
+    assert_eq!(dt.format("%V").unwrap().to_string(), "27");
+    assert_eq!(dt.format("%j").unwrap().to_string(), "189");
+    assert_eq!(dt.format("%D").unwrap().to_string(), "07/08/01");
+    assert_eq!(dt.format("%x").unwrap().to_string(), "07/08/01");
+    assert_eq!(dt.format("%F").unwrap().to_string(), "2001-07-08");
+    assert_eq!(dt.format("%v").unwrap().to_string(), " 8-Jul-2001");
 
     // time specifiers
-    assert_eq!(dt.format("%H").to_string(), "00");
-    assert_eq!(dt.format("%k").to_string(), " 0");
-    assert_eq!(dt.format("%k").to_string(), dt.format("%_H").to_string());
-    assert_eq!(dt.format("%I").to_string(), "12");
-    assert_eq!(dt.format("%l").to_string(), "12");
-    assert_eq!(dt.format("%l").to_string(), dt.format("%_I").to_string());
-    assert_eq!(dt.format("%P").to_string(), "am");
-    assert_eq!(dt.format("%p").to_string(), "AM");
-    assert_eq!(dt.format("%M").to_string(), "34");
-    assert_eq!(dt.format("%S").to_string(), "60");
-    assert_eq!(dt.format("%f").to_string(), "026490708");
-    assert_eq!(dt.format("%.f").to_string(), ".026490708");
-    assert_eq!(dt.with_nanosecond(1_026_490_000).unwrap().format("%.f").to_string(), ".026490");
-    assert_eq!(dt.format("%.3f").to_string(), ".026");
-    assert_eq!(dt.format("%.6f").to_string(), ".026490");
-    assert_eq!(dt.format("%.9f").to_string(), ".026490708");
-    assert_eq!(dt.format("%3f").to_string(), "026");
-    assert_eq!(dt.format("%6f").to_string(), "026490");
-    assert_eq!(dt.format("%9f").to_string(), "026490708");
-    assert_eq!(dt.format("%R").to_string(), "00:34");
-    assert_eq!(dt.format("%T").to_string(), "00:34:60");
-    assert_eq!(dt.format("%X").to_string(), "00:34:60");
-    assert_eq!(dt.format("%r").to_string(), "12:34:60 AM");
+    assert_eq!(dt.format("%H").unwrap().to_string(), "00");
+    assert_eq!(dt.format("%k").unwrap().to_string(), " 0");
+    assert_eq!(dt.format("%k").unwrap().to_string(), dt.format("%_H").unwrap().to_string());
+    assert_eq!(dt.format("%I").unwrap().to_string(), "12");
+    assert_eq!(dt.format("%l").unwrap().to_string(), "12");
+    assert_eq!(dt.format("%l").unwrap().to_string(), dt.format("%_I").unwrap().to_string());
+    assert_eq!(dt.format("%P").unwrap().to_string(), "am");
+    assert_eq!(dt.format("%p").unwrap().to_string(), "AM");
+    assert_eq!(dt.format("%M").unwrap().to_string(), "34");
+    assert_eq!(dt.format("%S").unwrap().to_string(), "60");
+    assert_eq!(dt.format("%f").unwrap().to_string(), "026490708");
+    assert_eq!(dt.format("%.f").unwrap().to_string(), ".026490708");
+    assert_eq!(
+        dt.with_nanosecond(1_026_490_000).unwrap().format("%.f").unwrap().to_string(),
+        ".026490"
+    );
+    assert_eq!(dt.format("%.3f").unwrap().to_string(), ".026");
+    assert_eq!(dt.format("%.6f").unwrap().to_string(), ".026490");
+    assert_eq!(dt.format("%.9f").unwrap().to_string(), ".026490708");
+    assert_eq!(dt.format("%3f").unwrap().to_string(), "026");
+    assert_eq!(dt.format("%6f").unwrap().to_string(), "026490");
+    assert_eq!(dt.format("%9f").unwrap().to_string(), "026490708");
+    assert_eq!(dt.format("%R").unwrap().to_string(), "00:34");
+    assert_eq!(dt.format("%T").unwrap().to_string(), "00:34:60");
+    assert_eq!(dt.format("%X").unwrap().to_string(), "00:34:60");
+    assert_eq!(dt.format("%r").unwrap().to_string(), "12:34:60 AM");
 
     // time zone specifiers
-    //assert_eq!(dt.format("%Z").to_string(), "ACST");
-    assert_eq!(dt.format("%z").to_string(), "+0930");
-    assert_eq!(dt.format("%:z").to_string(), "+09:30");
-    assert_eq!(dt.format("%::z").to_string(), "+09:30:00");
-    assert_eq!(dt.format("%:::z").to_string(), "+09");
+    //assert_eq!(dt.format("%Z").unwrap().to_string(), "ACST");
+    assert_eq!(dt.format("%z").unwrap().to_string(), "+0930");
+    assert_eq!(dt.format("%:z").unwrap().to_string(), "+09:30");
+    assert_eq!(dt.format("%::z").unwrap().to_string(), "+09:30:00");
+    assert_eq!(dt.format("%:::z").unwrap().to_string(), "+09");
 
     // date & time specifiers
-    assert_eq!(dt.format("%c").to_string(), "Sun Jul  8 00:34:60 2001");
-    assert_eq!(dt.format("%+").to_string(), "2001-07-08T00:34:60.026490708+09:30");
+    assert_eq!(dt.format("%c").unwrap().to_string(), "Sun Jul  8 00:34:60 2001");
+    assert_eq!(dt.format("%+").unwrap().to_string(), "2001-07-08T00:34:60.026490708+09:30");
 
     assert_eq!(
-        dt.with_timezone(&Utc).format("%+").to_string(),
+        dt.with_timezone(&Utc).format("%+").unwrap().to_string(),
         "2001-07-07T15:04:60.026490708+00:00"
     );
     assert_eq!(
@@ -649,15 +669,15 @@ fn test_strftime_docs() {
     );
 
     assert_eq!(
-        dt.with_nanosecond(1_026_490_000).unwrap().format("%+").to_string(),
+        dt.with_nanosecond(1_026_490_000).unwrap().format("%+").unwrap().to_string(),
         "2001-07-08T00:34:60.026490+09:30"
     );
-    assert_eq!(dt.format("%s").to_string(), "994518299");
+    assert_eq!(dt.format("%s").unwrap().to_string(), "994518299");
 
     // special specifiers
-    assert_eq!(dt.format("%t").to_string(), "\t");
-    assert_eq!(dt.format("%n").to_string(), "\n");
-    assert_eq!(dt.format("%%").to_string(), "%");
+    assert_eq!(dt.format("%t").unwrap().to_string(), "\t");
+    assert_eq!(dt.format("%n").unwrap().to_string(), "\n");
+    assert_eq!(dt.format("%%").unwrap().to_string(), "%");
 }
 
 #[cfg(feature = "unstable-locales")]
@@ -672,27 +692,27 @@ fn test_strftime_docs_localized() {
         .unwrap();
 
     // date specifiers
-    assert_eq!(dt.format_localized("%b", Locale::fr_BE).to_string(), "jui");
-    assert_eq!(dt.format_localized("%B", Locale::fr_BE).to_string(), "juillet");
-    assert_eq!(dt.format_localized("%h", Locale::fr_BE).to_string(), "jui");
-    assert_eq!(dt.format_localized("%a", Locale::fr_BE).to_string(), "dim");
-    assert_eq!(dt.format_localized("%A", Locale::fr_BE).to_string(), "dimanche");
-    assert_eq!(dt.format_localized("%D", Locale::fr_BE).to_string(), "07/08/01");
-    assert_eq!(dt.format_localized("%x", Locale::fr_BE).to_string(), "08/07/01");
-    assert_eq!(dt.format_localized("%F", Locale::fr_BE).to_string(), "2001-07-08");
-    assert_eq!(dt.format_localized("%v", Locale::fr_BE).to_string(), " 8-jui-2001");
+    assert_eq!(dt.format_localized("%b", Locale::fr_BE).unwrap().to_string(), "jui");
+    assert_eq!(dt.format_localized("%B", Locale::fr_BE).unwrap().to_string(), "juillet");
+    assert_eq!(dt.format_localized("%h", Locale::fr_BE).unwrap().to_string(), "jui");
+    assert_eq!(dt.format_localized("%a", Locale::fr_BE).unwrap().to_string(), "dim");
+    assert_eq!(dt.format_localized("%A", Locale::fr_BE).unwrap().to_string(), "dimanche");
+    assert_eq!(dt.format_localized("%D", Locale::fr_BE).unwrap().to_string(), "07/08/01");
+    assert_eq!(dt.format_localized("%x", Locale::fr_BE).unwrap().to_string(), "08/07/01");
+    assert_eq!(dt.format_localized("%F", Locale::fr_BE).unwrap().to_string(), "2001-07-08");
+    assert_eq!(dt.format_localized("%v", Locale::fr_BE).unwrap().to_string(), " 8-jui-2001");
 
     // time specifiers
-    assert_eq!(dt.format_localized("%P", Locale::fr_BE).to_string(), "");
-    assert_eq!(dt.format_localized("%p", Locale::fr_BE).to_string(), "");
-    assert_eq!(dt.format_localized("%R", Locale::fr_BE).to_string(), "00:34");
-    assert_eq!(dt.format_localized("%T", Locale::fr_BE).to_string(), "00:34:60");
-    assert_eq!(dt.format_localized("%X", Locale::fr_BE).to_string(), "00:34:60");
-    assert_eq!(dt.format_localized("%r", Locale::fr_BE).to_string(), "12:34:60 ");
+    assert_eq!(dt.format_localized("%P", Locale::fr_BE).unwrap().to_string(), "");
+    assert_eq!(dt.format_localized("%p", Locale::fr_BE).unwrap().to_string(), "");
+    assert_eq!(dt.format_localized("%R", Locale::fr_BE).unwrap().to_string(), "00:34");
+    assert_eq!(dt.format_localized("%T", Locale::fr_BE).unwrap().to_string(), "00:34:60");
+    assert_eq!(dt.format_localized("%X", Locale::fr_BE).unwrap().to_string(), "00:34:60");
+    assert_eq!(dt.format_localized("%r", Locale::fr_BE).unwrap().to_string(), "12:34:60 ");
 
     // date & time specifiers
     assert_eq!(
-        dt.format_localized("%c", Locale::fr_BE).to_string(),
+        dt.format_localized("%c", Locale::fr_BE).unwrap().to_string(),
         "dim 08 jui 2001 00:34:60 +09:30"
     );
 }