From c0643e193fe8d21a89f26ee8003d8b34fd1a769e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Tue, 24 Nov 2020 22:57:20 +0100 Subject: [PATCH 1/7] * Added Default implementation for NaiveDateTime, NaiveDate and NaiveTime * Added Default implmentation for DateTime and Date --- src/date.rs | 14 ++++++++++++++ src/datetime.rs | 14 ++++++++++++++ src/naive/date.rs | 14 ++++++++++++++ src/naive/datetime.rs | 15 +++++++++++++++ src/naive/time.rs | 14 ++++++++++++++ 5 files changed, 71 insertions(+) diff --git a/src/date.rs b/src/date.rs index a12f383a18..639c65fecd 100644 --- a/src/date.rs +++ b/src/date.rs @@ -494,3 +494,17 @@ where write!(f, "{}{}", self.naive_local(), self.offset) } } + +/// The default value for a DateTime 1st of January 1970 00:00:00 UTC. +/// +/// # Example +/// +/// ~~~~ +/// let default_date = DateTime::default(); +/// assert_eq!(default_date, DateTime::from_utc(NaiveDateTime::default(), 0)); +/// ~~~~ +impl Default for Date { + fn default() -> Self { + Date::from_utc(NaiveDate::default(), 0) + } +} diff --git a/src/datetime.rs b/src/datetime.rs index 0d68eb8417..f01ddf3e5a 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -899,6 +899,20 @@ impl From> for js_sys::Date { } } +/// The default value for a DateTime 1st of January 1970 00:00:00 UTC. +/// +/// # Example +/// +/// ~~~~ +/// let default_date = DateTime::default(); +/// assert_eq!(default_date, DateTime::from_utc(NaiveDateTime::default(), 0)); +/// ~~~~ +impl Default for DateTime { + fn default() -> Self { + DateTime::from_utc(NaiveDateTime::default(), 0) + } +} + #[test] fn test_auto_conversion() { let utc_dt = Utc.ymd(2018, 9, 5).and_hms(23, 58, 0); diff --git a/src/naive/date.rs b/src/naive/date.rs index 3e34e20741..16b6426ac4 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1714,6 +1714,20 @@ impl str::FromStr for NaiveDate { } } +/// The default for a NaiveDate is 1st of January 1970. +/// +/// # Example +/// +/// ~~~~ +/// let default_date = NaiveDate::default(); +/// assert_eq!(default_date, NaiveDate::from_ymd(1970, 1, 1)); +/// ~~~~ +impl Default for NaiveDate { + fn default() -> Self { + NaiveDate::from_ymd(1970, 1, 1) + } +} + #[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))] fn test_encodable_json(to_string: F) where diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index 234b0997ce..cb6344bd31 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -1511,6 +1511,21 @@ impl str::FromStr for NaiveDateTime { } } +/// The default for a NaiveDateTime is one with epoch 0 +/// that is 1st of January 1970 at 00:00:00. +/// +/// # Example +/// +/// ~~~~ +/// let default_date = NaiveDateTime::default(); +/// assert_eq!(default_date, NaiveDateTime::from_timestamp(0, 0)); +/// ~~~~ +impl Default for NaiveDateTime { + fn default() -> Self { + NaiveDateTime::from_timestamp(0, 0) + } +} + #[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))] fn test_encodable_json(to_string: F) where diff --git a/src/naive/time.rs b/src/naive/time.rs index 1ddc9fbedc..79e8795261 100644 --- a/src/naive/time.rs +++ b/src/naive/time.rs @@ -1341,6 +1341,20 @@ impl str::FromStr for NaiveTime { } } +/// The default for a NaiveTime is midnight, oo:oo:00 exactly. +/// +/// # Example +/// +/// ~~~~ +/// let default_time = NaiveTime::default(); +/// assert_eq!(default_time, NaiveTime::from_hms(0, 0, 0)); +/// ~~~~ +impl Default for NaiveTime { + fn default() -> Self { + NaiveTime::from_hms(0, 0, 0) + } +} + #[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))] fn test_encodable_json(to_string: F) where From 43e5f2a671044bdf684444726689b217a7177425 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Tue, 24 Nov 2020 23:41:59 +0100 Subject: [PATCH 2/7] * Removed non naive Default implmentations --- src/date.rs | 14 -------------- src/datetime.rs | 14 -------------- 2 files changed, 28 deletions(-) diff --git a/src/date.rs b/src/date.rs index 639c65fecd..a12f383a18 100644 --- a/src/date.rs +++ b/src/date.rs @@ -494,17 +494,3 @@ where write!(f, "{}{}", self.naive_local(), self.offset) } } - -/// The default value for a DateTime 1st of January 1970 00:00:00 UTC. -/// -/// # Example -/// -/// ~~~~ -/// let default_date = DateTime::default(); -/// assert_eq!(default_date, DateTime::from_utc(NaiveDateTime::default(), 0)); -/// ~~~~ -impl Default for Date { - fn default() -> Self { - Date::from_utc(NaiveDate::default(), 0) - } -} diff --git a/src/datetime.rs b/src/datetime.rs index f01ddf3e5a..0d68eb8417 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -899,20 +899,6 @@ impl From> for js_sys::Date { } } -/// The default value for a DateTime 1st of January 1970 00:00:00 UTC. -/// -/// # Example -/// -/// ~~~~ -/// let default_date = DateTime::default(); -/// assert_eq!(default_date, DateTime::from_utc(NaiveDateTime::default(), 0)); -/// ~~~~ -impl Default for DateTime { - fn default() -> Self { - DateTime::from_utc(NaiveDateTime::default(), 0) - } -} - #[test] fn test_auto_conversion() { let utc_dt = Utc.ymd(2018, 9, 5).and_hms(23, 58, 0); From a2b6d94e42c0dd5dfd86a4f31eaa6a6fa0c110e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Sun, 27 Dec 2020 12:07:55 +0100 Subject: [PATCH 3/7] * Fixed tests --- src/lib.rs | 48 +++++++++++++++++++++++-------------------- src/naive/date.rs | 2 ++ src/naive/datetime.rs | 2 ++ src/naive/time.rs | 2 ++ 4 files changed, 32 insertions(+), 22 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 7d77868782..f2e642da98 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -231,29 +231,33 @@ //! `unstable-locales`: //! //! ```text -//! chrono { version = "0.4", features = ["unstable-locales"] -//! ``` -//! -//! The `unstable-locales` feature requires and implies at least the `alloc` feature. -//! -//! ```rust -//! use chrono::prelude::*; -//! -//! let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); -//! assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09"); -//! assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014"); -//! assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), "vendredi 28 novembre 2014, 12:00:09"); -//! assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); -//! -//! assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC"); -//! assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000"); -//! assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00"); -//! assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z"); -//! -//! // Note that milli/nanoseconds are only printed if they are non-zero -//! let dt_nano = Utc.ymd(2014, 11, 28).and_hms_nano(12, 0, 9, 1); -//! assert_eq!(format!("{:?}", dt_nano), "2014-11-28T12:00:09.000000001Z"); +//! chrono = { version = "0.4", features = ["unstable-locales"] } //! ``` +#![cfg_attr( + feature = "unstable-locales", + doc = r##" +The `unstable-locales` feature requires and implies at least the `alloc` feature. + +```rust +use chrono::prelude::*; + +let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); +assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09"); +assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014"); +assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), "vendredi 28 novembre 2014, 12:00:09"); +assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); +//! +assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC"); +assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000"); +assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00"); +assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z"); +//! +// Note that milli/nanoseconds are only printed if they are non-zero +let dt_nano = Utc.ymd(2014, 11, 28).and_hms_nano(12, 0, 9, 1); +assert_eq!(format!("{:?}", dt_nano), "2014-11-28T12:00:09.000000001Z"); +``` +"## +)] //! //! Parsing can be done with three methods: //! diff --git a/src/naive/date.rs b/src/naive/date.rs index 16b6426ac4..b49669597c 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1719,6 +1719,8 @@ impl str::FromStr for NaiveDate { /// # Example /// /// ~~~~ +/// use chrono::NaiveDate; +/// /// let default_date = NaiveDate::default(); /// assert_eq!(default_date, NaiveDate::from_ymd(1970, 1, 1)); /// ~~~~ diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index cb6344bd31..80218bb8bd 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -1517,6 +1517,8 @@ impl str::FromStr for NaiveDateTime { /// # Example /// /// ~~~~ +/// use chrono::NaiveDateTime; +/// /// let default_date = NaiveDateTime::default(); /// assert_eq!(default_date, NaiveDateTime::from_timestamp(0, 0)); /// ~~~~ diff --git a/src/naive/time.rs b/src/naive/time.rs index 79e8795261..c9c424e008 100644 --- a/src/naive/time.rs +++ b/src/naive/time.rs @@ -1346,6 +1346,8 @@ impl str::FromStr for NaiveTime { /// # Example /// /// ~~~~ +/// use chrono::NaiveTime; +/// /// let default_time = NaiveTime::default(); /// assert_eq!(default_time, NaiveTime::from_hms(0, 0, 0)); /// ~~~~ From 3f895ec06b4bf2d4e9cbf06a6cee5134adeeeb2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Sun, 27 Dec 2020 13:14:16 +0100 Subject: [PATCH 4/7] * Adjusted doctest for unstable-locales --- README.md | 6 +++--- src/lib.rs | 56 +++++++++++++++++++++++++++++------------------------- 2 files changed, 33 insertions(+), 29 deletions(-) diff --git a/README.md b/README.md index 5a5a74b42a..48af06cfdb 100644 --- a/README.md +++ b/README.md @@ -238,8 +238,8 @@ Chrono now also provides date formatting in almost any language without the help of an additional C library. This functionality is under the feature `unstable-locales`: -```text -chrono { version = "0.4", features = ["unstable-locales"] +```toml +chrono = { version = "0.4", features = ["unstable-locales"] } ``` The `unstable-locales` feature requires and implies at least the `alloc` feature. @@ -251,8 +251,8 @@ let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09"); assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014"); assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), "vendredi 28 novembre 2014, 12:00:09"); -assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); +assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC"); assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000"); assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00"); diff --git a/src/lib.rs b/src/lib.rs index f2e642da98..23c94e693a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -230,34 +230,38 @@ //! help of an additional C library. This functionality is under the feature //! `unstable-locales`: //! -//! ```text +//! ```toml //! chrono = { version = "0.4", features = ["unstable-locales"] } //! ``` -#![cfg_attr( - feature = "unstable-locales", - doc = r##" -The `unstable-locales` feature requires and implies at least the `alloc` feature. - -```rust -use chrono::prelude::*; - -let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); -assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09"); -assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014"); -assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), "vendredi 28 novembre 2014, 12:00:09"); -assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); -//! -assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC"); -assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000"); -assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00"); -assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z"); -//! -// Note that milli/nanoseconds are only printed if they are non-zero -let dt_nano = Utc.ymd(2014, 11, 28).and_hms_nano(12, 0, 9, 1); -assert_eq!(format!("{:?}", dt_nano), "2014-11-28T12:00:09.000000001Z"); -``` -"## -)] +//! +//! The `unstable-locales` feature requires and implies at least the `alloc` feature. +//! +//! ```rust +//! use chrono::prelude::*; +//! +//! # #[cfg(feature = "unstable-locales")] +//! # fn test() { +//! let dt = Utc.ymd(2014, 11, 28).and_hms(12, 0, 9); +//! assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09"); +//! assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014"); +//! assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), "vendredi 28 novembre 2014, 12:00:09"); +//! +//! assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string()); +//! assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC"); +//! assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000"); +//! assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00"); +//! assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z"); +//! +//! // Note that milli/nanoseconds are only printed if they are non-zero +//! let dt_nano = Utc.ymd(2014, 11, 28).and_hms_nano(12, 0, 9, 1); +//! assert_eq!(format!("{:?}", dt_nano), "2014-11-28T12:00:09.000000001Z"); +//! # } +//! # #[cfg(not(feature = "unstable-locales"))] +//! # fn test() {} +//! # if cfg!(feature = "unstable-locales") { +//! # test(); +//! # } +//! ``` //! //! Parsing can be done with three methods: //! From 9bf16699b0cfcad84502b5d5ddb415d4c11f9262 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Sun, 27 Dec 2020 14:03:07 +0100 Subject: [PATCH 5/7] * Added Default implementations for Utc, Local and FixedOffset timezones --- src/datetime.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/datetime.rs b/src/datetime.rs index 0d68eb8417..6235c26033 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -310,6 +310,24 @@ impl DateTime { } } +impl Default for DateTime { + fn default() -> Self { + Utc.from_utc_datetime(&NaiveDateTime::default()) + } +} + +impl Default for DateTime { + fn default() -> Self { + Local.from_utc_datetime(&NaiveDateTime::default()) + } +} + +impl Default for DateTime { + fn default() -> Self { + FixedOffset::west(0).from_utc_datetime(&NaiveDateTime::default()) + } +} + /// Convert a `DateTime` instance into a `DateTime` instance. impl From> for DateTime { /// Convert this `DateTime` instance into a `DateTime` instance. From c6010415349a44930e9f5bcbb062654de0805e3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Sun, 27 Dec 2020 14:08:39 +0100 Subject: [PATCH 6/7] * Added missing config flag --- src/datetime.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/datetime.rs b/src/datetime.rs index 6235c26033..9ae04d8cbe 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -316,6 +316,7 @@ impl Default for DateTime { } } +#[cfg(feature = "clock")] impl Default for DateTime { fn default() -> Self { Local.from_utc_datetime(&NaiveDateTime::default()) From a1cbbaab6161db7813267af576aaa527ef793d67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=ADdac=20Sement=C3=A9=20Fern=C3=A1ndez?= Date: Thu, 31 Dec 2020 15:32:02 +0100 Subject: [PATCH 7/7] * Modified documentation examples * Fixed typo in NaiveTime docs for Default --- src/naive/date.rs | 6 +++--- src/naive/datetime.rs | 8 ++++---- src/naive/time.rs | 6 +++--- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/naive/date.rs b/src/naive/date.rs index b49669597c..43c81e466c 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -1714,16 +1714,16 @@ impl str::FromStr for NaiveDate { } } -/// The default for a NaiveDate is 1st of January 1970. +/// The default value for a NaiveDate is 1st of January 1970. /// /// # Example /// -/// ~~~~ +/// ```rust /// use chrono::NaiveDate; /// /// let default_date = NaiveDate::default(); /// assert_eq!(default_date, NaiveDate::from_ymd(1970, 1, 1)); -/// ~~~~ +/// ``` impl Default for NaiveDate { fn default() -> Self { NaiveDate::from_ymd(1970, 1, 1) diff --git a/src/naive/datetime.rs b/src/naive/datetime.rs index 80218bb8bd..a2d00dbe47 100644 --- a/src/naive/datetime.rs +++ b/src/naive/datetime.rs @@ -1511,17 +1511,17 @@ impl str::FromStr for NaiveDateTime { } } -/// The default for a NaiveDateTime is one with epoch 0 -/// that is 1st of January 1970 at 00:00:00. +/// The default value for a NaiveDateTime is one with epoch 0 +/// that is, 1st of January 1970 at 00:00:00. /// /// # Example /// -/// ~~~~ +/// ```rust /// use chrono::NaiveDateTime; /// /// let default_date = NaiveDateTime::default(); /// assert_eq!(default_date, NaiveDateTime::from_timestamp(0, 0)); -/// ~~~~ +/// ``` impl Default for NaiveDateTime { fn default() -> Self { NaiveDateTime::from_timestamp(0, 0) diff --git a/src/naive/time.rs b/src/naive/time.rs index c9c424e008..bb00709a05 100644 --- a/src/naive/time.rs +++ b/src/naive/time.rs @@ -1341,16 +1341,16 @@ impl str::FromStr for NaiveTime { } } -/// The default for a NaiveTime is midnight, oo:oo:00 exactly. +/// The default value for a NaiveTime is midnight, 00:00:00 exactly. /// /// # Example /// -/// ~~~~ +/// ```rust /// use chrono::NaiveTime; /// /// let default_time = NaiveTime::default(); /// assert_eq!(default_time, NaiveTime::from_hms(0, 0, 0)); -/// ~~~~ +/// ``` impl Default for NaiveTime { fn default() -> Self { NaiveTime::from_hms(0, 0, 0)