itsscb/chrono
1
0
Fork 0
mirror of https://github.com/chronotope/chrono.git synced 2025-10-02 15:26:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

TimeZone trait: take NaiveDateTime by value

Browse Source
This commit is contained in:
Paul Dicker 2024-03-16 07:42:17 +01:00 committed by Paul Dicker
parent f1c72a5382
commit 18b96a16a9
18 changed files with 157 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bench/benches/chrono.rs
View File

@ -50,7 +50,7 @@ fn bench_datetime_to_rfc2822(c: &mut Criterion) {
let pst = FixedOffset::east(8 * 60 * 60).unwrap(); let pst = FixedOffset::east(8 * 60 * 60).unwrap();
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(), NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(),
) )
.unwrap(); .unwrap();
c.bench_function("bench_datetime_to_rfc2822", |b| b.iter(|| black_box(dt).to_rfc2822())); c.bench_function("bench_datetime_to_rfc2822", |b| b.iter(|| black_box(dt).to_rfc2822()));
@ -60,7 +60,7 @@ fn bench_datetime_to_rfc3339(c: &mut Criterion) {
let pst = FixedOffset::east(8 * 60 * 60).unwrap(); let pst = FixedOffset::east(8 * 60 * 60).unwrap();
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(), NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(),
) )
.unwrap(); .unwrap();
c.bench_function("bench_datetime_to_rfc3339", |b| b.iter(|| black_box(dt).to_rfc3339())); c.bench_function("bench_datetime_to_rfc3339", |b| b.iter(|| black_box(dt).to_rfc3339()));
@ -70,7 +70,7 @@ fn bench_datetime_to_rfc3339_opts(c: &mut Criterion) {
let pst = FixedOffset::east(8 * 60 * 60).unwrap(); let pst = FixedOffset::east(8 * 60 * 60).unwrap();
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(), NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(),
) )
.unwrap(); .unwrap();
c.bench_function("bench_datetime_to_rfc3339_opts", |b| { c.bench_function("bench_datetime_to_rfc3339_opts", |b| {

28
src/datetime/mod.rs
View File

@ -285,7 +285,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
#[inline] #[inline]
#[must_use] #[must_use]
pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> DateTime<Tz2> { pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> DateTime<Tz2> {
tz.from_utc_datetime(&self.datetime) tz.from_utc_datetime(self.datetime)
} }
/// Fix the offset from UTC to its current value, dropping the associated timezone information. /// Fix the offset from UTC to its current value, dropping the associated timezone information.
@ -314,7 +314,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
pub fn checked_add_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>> { pub fn checked_add_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>> {
let datetime = self.datetime.checked_add_signed(rhs).ok()?; let datetime = self.datetime.checked_add_signed(rhs).ok()?;
let tz = self.timezone(); let tz = self.timezone();
Some(tz.from_utc_datetime(&datetime)) Some(tz.from_utc_datetime(datetime))
} }
/// Adds given `Months` to the current date and time. /// Adds given `Months` to the current date and time.
@ -351,7 +351,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
pub fn checked_sub_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>> { pub fn checked_sub_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>> {
let datetime = self.datetime.checked_sub_signed(rhs).ok()?; let datetime = self.datetime.checked_sub_signed(rhs).ok()?;
let tz = self.timezone(); let tz = self.timezone();
Some(tz.from_utc_datetime(&datetime)) Some(tz.from_utc_datetime(datetime))
} }
/// Subtracts given `Months` from the current date and time. /// Subtracts given `Months` from the current date and time.
@ -397,7 +397,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
// range local datetime when adding `Days(0)`. // range local datetime when adding `Days(0)`.
let naive = self.overflowing_naive_local().checked_add_days(days).ok()?; let naive = self.overflowing_naive_local().checked_add_days(days).ok()?;
self.timezone() self.timezone()
.from_local_datetime(&naive) .from_local_datetime(naive)
.single() .single()
.filter(|dt| dt <= &DateTime::<Utc>::MAX_UTC) .filter(|dt| dt <= &DateTime::<Utc>::MAX_UTC)
} }
@ -418,7 +418,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
// range local datetime when adding `Days(0)`. // range local datetime when adding `Days(0)`.
let naive = self.overflowing_naive_local().checked_sub_days(days).ok()?; let naive = self.overflowing_naive_local().checked_sub_days(days).ok()?;
self.timezone() self.timezone()
.from_local_datetime(&naive) .from_local_datetime(naive)
.single() .single()
.filter(|dt| dt >= &DateTime::<Utc>::MIN_UTC) .filter(|dt| dt >= &DateTime::<Utc>::MIN_UTC)
} }
@ -541,7 +541,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
/// let pst = FixedOffset::east(8 * 60 * 60).unwrap(); /// let pst = FixedOffset::east(8 * 60 * 60).unwrap();
/// let dt = pst /// let dt = pst
/// .from_local_datetime( /// .from_local_datetime(
/// &NaiveDate::from_ymd(2018, 1, 26).unwrap().and_hms_micro(10, 30, 9, 453_829).unwrap(), /// NaiveDate::from_ymd(2018, 1, 26).unwrap().and_hms_micro(10, 30, 9, 453_829).unwrap(),
/// ) /// )
/// .unwrap(); /// .unwrap();
/// assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00"); /// assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00");
@ -696,7 +696,7 @@ impl<Tz: TimeZone> DateTime<Tz> {
/// ``` /// ```
#[must_use] #[must_use]
pub fn with_time(&self, time: NaiveTime) -> MappedLocalTime<Self> { pub fn with_time(&self, time: NaiveTime) -> MappedLocalTime<Self> {
self.timezone().from_local_datetime(&self.overflowing_naive_local().date().and_time(time)) self.timezone().from_local_datetime(self.overflowing_naive_local().date().and_time(time))
} }
/// Makes a new `DateTime` with the hour number changed. /// Makes a new `DateTime` with the hour number changed.
@ -919,20 +919,20 @@ impl DateTime<Utc> {
impl Default for DateTime<Utc> { impl Default for DateTime<Utc> {
fn default() -> Self { fn default() -> Self {
Utc.from_utc_datetime(&NaiveDateTime::default()) Utc.from_utc_datetime(NaiveDateTime::default())
} }
} }
#[cfg(feature = "clock")] #[cfg(feature = "clock")]
impl Default for DateTime<Local> { impl Default for DateTime<Local> {
fn default() -> Self { fn default() -> Self {
Local.from_utc_datetime(&NaiveDateTime::default()) Local.from_utc_datetime(NaiveDateTime::default())
} }
} }
impl Default for DateTime<FixedOffset> { impl Default for DateTime<FixedOffset> {
fn default() -> Self { fn default() -> Self {
FixedOffset::west(0).unwrap().from_utc_datetime(&NaiveDateTime::default()) FixedOffset::west(0).unwrap().from_utc_datetime(NaiveDateTime::default())
} }
} }
@ -1010,7 +1010,7 @@ where
F: FnMut(NaiveDateTime) -> Option<NaiveDateTime>, F: FnMut(NaiveDateTime) -> Option<NaiveDateTime>,
{ {
f(dt.overflowing_naive_local()) f(dt.overflowing_naive_local())
.and_then(|datetime| dt.timezone().from_local_datetime(&datetime).single()) .and_then(|datetime| dt.timezone().from_local_datetime(datetime).single())
.filter(|dt| dt >= &DateTime::<Utc>::MIN_UTC && dt <= &DateTime::<Utc>::MAX_UTC) .filter(|dt| dt >= &DateTime::<Utc>::MIN_UTC && dt <= &DateTime::<Utc>::MAX_UTC)
} }
@ -1097,7 +1097,7 @@ impl DateTime<FixedOffset> {
/// Ok(FixedOffset::east(0) /// Ok(FixedOffset::east(0)
/// .unwrap() /// .unwrap()
/// .from_local_datetime( /// .from_local_datetime(
/// &NaiveDate::from_ymd(1983, 4, 13).unwrap().and_hms_milli(12, 9, 14, 274).unwrap() /// NaiveDate::from_ymd(1983, 4, 13).unwrap().and_hms_milli(12, 9, 14, 274).unwrap()
/// ) /// )
/// .unwrap()) /// .unwrap())
/// ); /// );
@ -1390,7 +1390,7 @@ impl<Tz: TimeZone> AddAssign<TimeDelta> for DateTime<Tz> {
let datetime = let datetime =
self.datetime.checked_add_signed(rhs).expect("`DateTime + TimeDelta` overflowed"); self.datetime.checked_add_signed(rhs).expect("`DateTime + TimeDelta` overflowed");
let tz = self.timezone(); let tz = self.timezone();
*self = tz.from_utc_datetime(&datetime); *self = tz.from_utc_datetime(datetime);
} }
} }
@ -1510,7 +1510,7 @@ impl<Tz: TimeZone> SubAssign<TimeDelta> for DateTime<Tz> {
let datetime = let datetime =
self.datetime.checked_sub_signed(rhs).expect("`DateTime - TimeDelta` overflowed"); self.datetime.checked_sub_signed(rhs).expect("`DateTime - TimeDelta` overflowed");
let tz = self.timezone(); let tz = self.timezone();
*self = tz.from_utc_datetime(&datetime) *self = tz.from_utc_datetime(datetime)
} }
} }

4
src/datetime/serde.rs
View File

@ -1252,11 +1252,11 @@ mod tests {
} }
fn offset_from_local_datetime( fn offset_from_local_datetime(
&self, &self,
_local: &NaiveDateTime, _local: NaiveDateTime,
) -> MappedLocalTime<TestTimeZone> { ) -> MappedLocalTime<TestTimeZone> {
MappedLocalTime::Single(TestTimeZone) MappedLocalTime::Single(TestTimeZone)
} }
fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> TestTimeZone { fn offset_from_utc_datetime(&self, _utc: NaiveDateTime) -> TestTimeZone {
TestTimeZone TestTimeZone
} }
} }

116
src/datetime/tests.rs
View File

@ -35,7 +35,7 @@ impl TimeZone for DstTester {
fn offset_from_local_datetime( fn offset_from_local_datetime(
&self, &self,
local: &NaiveDateTime, local: NaiveDateTime,
) -> crate::MappedLocalTime<Self::Offset> { ) -> crate::MappedLocalTime<Self::Offset> {
let local_to_winter_transition_start = NaiveDate::from_ymd( let local_to_winter_transition_start = NaiveDate::from_ymd(
local.year(), local.year(),
@ -69,18 +69,18 @@ impl TimeZone for DstTester {
.unwrap() .unwrap()
.and_time(DstTester::transition_start_local() + TimeDelta::hours(1)); .and_time(DstTester::transition_start_local() + TimeDelta::hours(1));
if *local < local_to_winter_transition_end || *local >= local_to_summer_transition_end { if local < local_to_winter_transition_end || local >= local_to_summer_transition_end {
MappedLocalTime::Single(DstTester::summer_offset()) MappedLocalTime::Single(DstTester::summer_offset())
} else if *local >= local_to_winter_transition_start } else if local >= local_to_winter_transition_start
&& *local < local_to_summer_transition_start && local < local_to_summer_transition_start
{ {
MappedLocalTime::Single(DstTester::winter_offset()) MappedLocalTime::Single(DstTester::winter_offset())
} else if *local >= local_to_winter_transition_end } else if local >= local_to_winter_transition_end
&& *local < local_to_winter_transition_start && local < local_to_winter_transition_start
{ {
MappedLocalTime::Ambiguous(DstTester::winter_offset(), DstTester::summer_offset()) MappedLocalTime::Ambiguous(DstTester::winter_offset(), DstTester::summer_offset())
} else if *local >= local_to_summer_transition_start } else if local >= local_to_summer_transition_start
&& *local < local_to_summer_transition_end && local < local_to_summer_transition_end
{ {
MappedLocalTime::None MappedLocalTime::None
} else { } else {
@ -88,7 +88,7 @@ impl TimeZone for DstTester {
} }
} }
fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset { fn offset_from_utc_datetime(&self, utc: NaiveDateTime) -> Self::Offset {
let utc_to_winter_transition = NaiveDate::from_ymd( let utc_to_winter_transition = NaiveDate::from_ymd(
utc.year(), utc.year(),
DstTester::TO_WINTER_MONTH_DAY.0, DstTester::TO_WINTER_MONTH_DAY.0,
@ -107,9 +107,9 @@ impl TimeZone for DstTester {
.and_time(DstTester::transition_start_local()) .and_time(DstTester::transition_start_local())
- DstTester::winter_offset(); - DstTester::winter_offset();
if *utc < utc_to_winter_transition || *utc >= utc_to_summer_transition { if utc < utc_to_winter_transition || utc >= utc_to_summer_transition {
DstTester::summer_offset() DstTester::summer_offset()
} else if *utc >= utc_to_winter_transition && *utc < utc_to_summer_transition { } else if utc >= utc_to_winter_transition && utc < utc_to_summer_transition {
DstTester::winter_offset() DstTester::winter_offset()
} else { } else {
panic!("Unexpected utc time {}", utc) panic!("Unexpected utc time {}", utc)
@ -644,7 +644,7 @@ fn test_datetime_rfc2822() {
// timezone +05 // timezone +05
assert_eq!( assert_eq!(
edt.from_local_datetime( edt.from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap() .unwrap()
.to_rfc2822(), .to_rfc2822(),
@ -654,10 +654,7 @@ fn test_datetime_rfc2822() {
DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:59:60 +0500"), DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:59:60 +0500"),
Ok(edt Ok(edt
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18) NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 59, 59, 1_000).unwrap()
.unwrap()
.and_hms_milli(23, 59, 59, 1_000)
.unwrap()
) )
.unwrap()) .unwrap())
); );
@ -666,7 +663,7 @@ fn test_datetime_rfc2822() {
DateTime::parse_from_rfc3339("2015-02-18T23:59:60.234567+05:00"), DateTime::parse_from_rfc3339("2015-02-18T23:59:60.234567+05:00"),
Ok(edt Ok(edt
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18) NaiveDate::from_ymd(2015, 2, 18)
.unwrap() .unwrap()
.and_hms_micro(23, 59, 59, 1_234_567) .and_hms_micro(23, 59, 59, 1_234_567)
.unwrap() .unwrap()
@ -676,10 +673,7 @@ fn test_datetime_rfc2822() {
// seconds 60 // seconds 60
assert_eq!( assert_eq!(
edt.from_local_datetime( edt.from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18) NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_micro(23, 59, 59, 1_234_567).unwrap()
.unwrap()
.and_hms_micro(23, 59, 59, 1_234_567)
.unwrap()
) )
.unwrap() .unwrap()
.to_rfc2822(), .to_rfc2822(),
@ -762,7 +756,7 @@ fn test_datetime_rfc3339() {
// timezone +05 // timezone +05
assert_eq!( assert_eq!(
edt5.from_local_datetime( edt5.from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap() .unwrap()
.to_rfc3339(), .to_rfc3339(),
@ -838,7 +832,7 @@ fn test_rfc3339_opts() {
let pst = FixedOffset::east(8 * 60 * 60).unwrap(); let pst = FixedOffset::east(8 * 60 * 60).unwrap();
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(), NaiveDate::from_ymd(2018, 1, 11).unwrap().and_hms_nano(10, 5, 13, 84_660_000).unwrap(),
) )
.unwrap(); .unwrap();
assert_eq!(dt.to_rfc3339_opts(Secs, false), "2018-01-11T10:05:13+08:00"); assert_eq!(dt.to_rfc3339_opts(Secs, false), "2018-01-11T10:05:13+08:00");
@ -865,7 +859,7 @@ fn test_datetime_from_str() {
Ok(FixedOffset::east(0) Ok(FixedOffset::east(0)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -873,7 +867,7 @@ fn test_datetime_from_str() {
"2015-02-18T23:16:9.15Z".parse::<DateTime<Utc>>(), "2015-02-18T23:16:9.15Z".parse::<DateTime<Utc>>(),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -881,7 +875,7 @@ fn test_datetime_from_str() {
"2015-02-18T23:16:9.15 UTC".parse::<DateTime<Utc>>(), "2015-02-18T23:16:9.15 UTC".parse::<DateTime<Utc>>(),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -889,7 +883,7 @@ fn test_datetime_from_str() {
"2015-02-18T23:16:9.15UTC".parse::<DateTime<Utc>>(), "2015-02-18T23:16:9.15UTC".parse::<DateTime<Utc>>(),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -897,7 +891,7 @@ fn test_datetime_from_str() {
"2015-02-18T23:16:9.15Utc".parse::<DateTime<Utc>>(), "2015-02-18T23:16:9.15Utc".parse::<DateTime<Utc>>(),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -907,7 +901,7 @@ fn test_datetime_from_str() {
Ok(FixedOffset::east(0) Ok(FixedOffset::east(0)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -916,7 +910,7 @@ fn test_datetime_from_str() {
Ok(FixedOffset::west(10 * 3600) Ok(FixedOffset::west(10 * 3600)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(13, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(13, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -926,7 +920,7 @@ fn test_datetime_from_str() {
"2015-2-18T23:16:9.15Z".parse::<DateTime<Utc>>(), "2015-2-18T23:16:9.15Z".parse::<DateTime<Utc>>(),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -934,7 +928,7 @@ fn test_datetime_from_str() {
"2015-2-18T13:16:9.15-10:00".parse::<DateTime<Utc>>(), "2015-2-18T13:16:9.15-10:00".parse::<DateTime<Utc>>(),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap() NaiveDate::from_ymd(2015, 2, 18).unwrap().and_hms_milli(23, 16, 9, 150).unwrap()
) )
.unwrap()) .unwrap())
); );
@ -1269,7 +1263,7 @@ fn test_datetime_is_send_and_copy() {
fn test_subsecond_part() { fn test_subsecond_part() {
let datetime = Utc let datetime = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2014, 7, 8).unwrap().and_hms_nano(9, 10, 11, 1234567).unwrap(), NaiveDate::from_ymd(2014, 7, 8).unwrap().and_hms_nano(9, 10, 11, 1234567).unwrap(),
) )
.unwrap(); .unwrap();
@ -1295,21 +1289,21 @@ fn test_from_system_time() {
assert_eq!( assert_eq!(
DateTime::<Utc>::try_from(UNIX_EPOCH + Duration::new(999_999_999, nanos)).unwrap(), DateTime::<Utc>::try_from(UNIX_EPOCH + Duration::new(999_999_999, nanos)).unwrap(),
Utc.from_local_datetime( Utc.from_local_datetime(
&NaiveDate::from_ymd(2001, 9, 9).unwrap().and_hms_nano(1, 46, 39, nanos).unwrap() NaiveDate::from_ymd(2001, 9, 9).unwrap().and_hms_nano(1, 46, 39, nanos).unwrap()
) )
.unwrap() .unwrap()
); );
assert_eq!( assert_eq!(
DateTime::<Utc>::try_from(UNIX_EPOCH - Duration::new(999_999_999, nanos)).unwrap(), DateTime::<Utc>::try_from(UNIX_EPOCH - Duration::new(999_999_999, nanos)).unwrap(),
Utc.from_local_datetime( Utc.from_local_datetime(
&NaiveDate::from_ymd(1938, 4, 24).unwrap().and_hms_nano(22, 13, 20, 1_000).unwrap() NaiveDate::from_ymd(1938, 4, 24).unwrap().and_hms_nano(22, 13, 20, 1_000).unwrap()
) )
.unwrap() .unwrap()
); );
assert_eq!( assert_eq!(
DateTime::<Utc>::try_from(UNIX_EPOCH - Duration::new(999_999_999, 0)).unwrap(), DateTime::<Utc>::try_from(UNIX_EPOCH - Duration::new(999_999_999, 0)).unwrap(),
Utc.from_local_datetime( Utc.from_local_datetime(
&NaiveDate::from_ymd(1938, 4, 24).unwrap().and_hms_nano(22, 13, 21, 0).unwrap() NaiveDate::from_ymd(1938, 4, 24).unwrap().and_hms_nano(22, 13, 21, 0).unwrap()
) )
.unwrap() .unwrap()
); );
@ -1319,7 +1313,7 @@ fn test_from_system_time() {
assert_eq!( assert_eq!(
SystemTime::try_from( SystemTime::try_from(
Utc.from_local_datetime( Utc.from_local_datetime(
&NaiveDate::from_ymd(2001, 9, 9).unwrap().and_hms_nano(1, 46, 39, nanos).unwrap() NaiveDate::from_ymd(2001, 9, 9).unwrap().and_hms_nano(1, 46, 39, nanos).unwrap()
) )
.unwrap() .unwrap()
) )
@ -1329,7 +1323,7 @@ fn test_from_system_time() {
assert_eq!( assert_eq!(
SystemTime::try_from( SystemTime::try_from(
Utc.from_local_datetime( Utc.from_local_datetime(
&NaiveDate::from_ymd(1938, 4, 24).unwrap().and_hms_nano(22, 13, 20, 1_000).unwrap() NaiveDate::from_ymd(1938, 4, 24).unwrap().and_hms_nano(22, 13, 20, 1_000).unwrap()
) )
.unwrap() .unwrap()
) )
@ -1363,7 +1357,7 @@ fn test_datetime_before_windows_api_limits() {
// This used to fail on Windows for timezones with an offset of -5:00 or greater. // This used to fail on Windows for timezones with an offset of -5:00 or greater.
// The API limits years to 1601..=30827. // The API limits years to 1601..=30827.
let dt = NaiveDate::from_ymd(1601, 1, 1).unwrap().and_hms_milli(4, 5, 22, 122).unwrap(); let dt = NaiveDate::from_ymd(1601, 1, 1).unwrap().and_hms_milli(4, 5, 22, 122).unwrap();
let local_dt = Local.from_utc_datetime(&dt); let local_dt = Local.from_utc_datetime(dt);
dbg!(local_dt); dbg!(local_dt);
} }
@ -1410,8 +1404,8 @@ fn test_datetime_add_assign() {
fn test_datetime_add_assign_local() { fn test_datetime_add_assign_local() {
let naivedatetime = NaiveDate::from_ymd(2022, 1, 1).unwrap().and_hms(0, 0, 0).unwrap(); let naivedatetime = NaiveDate::from_ymd(2022, 1, 1).unwrap().and_hms(0, 0, 0).unwrap();
let datetime = Local.from_utc_datetime(&naivedatetime); let datetime = Local.from_utc_datetime(naivedatetime);
let mut datetime_add = Local.from_utc_datetime(&naivedatetime); let mut datetime_add = Local.from_utc_datetime(naivedatetime);
// ensure we cross a DST transition // ensure we cross a DST transition
for i in 1..=365 { for i in 1..=365 {
@ -1445,9 +1439,9 @@ fn test_datetime_sub_assign() {
#[test] #[test]
fn test_min_max_getters() { fn test_min_max_getters() {
let offset_min = FixedOffset::west(2 * 60 * 60).unwrap(); let offset_min = FixedOffset::west(2 * 60 * 60).unwrap();
let beyond_min = offset_min.from_utc_datetime(&NaiveDateTime::MIN); let beyond_min = offset_min.from_utc_datetime(NaiveDateTime::MIN);
let offset_max = FixedOffset::east(2 * 60 * 60).unwrap(); let offset_max = FixedOffset::east(2 * 60 * 60).unwrap();
let beyond_max = offset_max.from_utc_datetime(&NaiveDateTime::MAX); let beyond_max = offset_max.from_utc_datetime(NaiveDateTime::MAX);
assert_eq!(format!("{:?}", beyond_min), "-262144-12-31T22:00:00-02:00"); assert_eq!(format!("{:?}", beyond_min), "-262144-12-31T22:00:00-02:00");
// RFC 2822 doesn't support years with more than 4 digits. // RFC 2822 doesn't support years with more than 4 digits.
@ -1503,9 +1497,9 @@ fn test_min_max_getters() {
#[test] #[test]
fn test_min_max_setters() { fn test_min_max_setters() {
let offset_min = FixedOffset::west(2 * 60 * 60).unwrap(); let offset_min = FixedOffset::west(2 * 60 * 60).unwrap();
let beyond_min = offset_min.from_utc_datetime(&NaiveDateTime::MIN); let beyond_min = offset_min.from_utc_datetime(NaiveDateTime::MIN);
let offset_max = FixedOffset::east(2 * 60 * 60).unwrap(); let offset_max = FixedOffset::east(2 * 60 * 60).unwrap();
let beyond_max = offset_max.from_utc_datetime(&NaiveDateTime::MAX); let beyond_max = offset_max.from_utc_datetime(NaiveDateTime::MAX);
assert_eq!(beyond_min.with_year(2020).unwrap().year(), 2020); assert_eq!(beyond_min.with_year(2020).unwrap().year(), 2020);
assert_eq!(beyond_min.with_year(beyond_min.year()), Some(beyond_min)); assert_eq!(beyond_min.with_year(beyond_min.year()), Some(beyond_min));
@ -1553,15 +1547,15 @@ fn test_min_max_setters() {
#[test] #[test]
fn test_min_max_add_days() { fn test_min_max_add_days() {
let offset_min = FixedOffset::west(2 * 60 * 60).unwrap(); let offset_min = FixedOffset::west(2 * 60 * 60).unwrap();
let beyond_min = offset_min.from_utc_datetime(&NaiveDateTime::MIN); let beyond_min = offset_min.from_utc_datetime(NaiveDateTime::MIN);
let offset_max = FixedOffset::east(2 * 60 * 60).unwrap(); let offset_max = FixedOffset::east(2 * 60 * 60).unwrap();
let beyond_max = offset_max.from_utc_datetime(&NaiveDateTime::MAX); let beyond_max = offset_max.from_utc_datetime(NaiveDateTime::MAX);
let max_time = NaiveTime::from_hms_nano(23, 59, 59, 999_999_999).unwrap(); let max_time = NaiveTime::from_hms_nano(23, 59, 59, 999_999_999).unwrap();
assert_eq!(beyond_min.checked_add_days(Days::new(0)), Some(beyond_min)); assert_eq!(beyond_min.checked_add_days(Days::new(0)), Some(beyond_min));
assert_eq!( assert_eq!(
beyond_min.checked_add_days(Days::new(1)), beyond_min.checked_add_days(Days::new(1)),
Some(offset_min.from_utc_datetime(&(NaiveDate::MIN + Days(1)).and_time(NaiveTime::MIN))) Some(offset_min.from_utc_datetime((NaiveDate::MIN + Days(1)).and_time(NaiveTime::MIN)))
); );
assert_eq!(beyond_min.checked_sub_days(Days::new(0)), Some(beyond_min)); assert_eq!(beyond_min.checked_sub_days(Days::new(0)), Some(beyond_min));
assert_eq!(beyond_min.checked_sub_days(Days::new(1)), None); assert_eq!(beyond_min.checked_sub_days(Days::new(1)), None);
@ -1571,22 +1565,22 @@ fn test_min_max_add_days() {
assert_eq!(beyond_max.checked_sub_days(Days::new(0)), Some(beyond_max)); assert_eq!(beyond_max.checked_sub_days(Days::new(0)), Some(beyond_max));
assert_eq!( assert_eq!(
beyond_max.checked_sub_days(Days::new(1)), beyond_max.checked_sub_days(Days::new(1)),
Some(offset_max.from_utc_datetime(&(NaiveDate::MAX - Days(1)).and_time(max_time))) Some(offset_max.from_utc_datetime((NaiveDate::MAX - Days(1)).and_time(max_time)))
); );
} }
#[test] #[test]
fn test_min_max_add_months() { fn test_min_max_add_months() {
let offset_min = FixedOffset::west(2 * 60 * 60).unwrap(); let offset_min = FixedOffset::west(2 * 60 * 60).unwrap();
let beyond_min = offset_min.from_utc_datetime(&NaiveDateTime::MIN); let beyond_min = offset_min.from_utc_datetime(NaiveDateTime::MIN);
let offset_max = FixedOffset::east(2 * 60 * 60).unwrap(); let offset_max = FixedOffset::east(2 * 60 * 60).unwrap();
let beyond_max = offset_max.from_utc_datetime(&NaiveDateTime::MAX); let beyond_max = offset_max.from_utc_datetime(NaiveDateTime::MAX);
let max_time = NaiveTime::from_hms_nano(23, 59, 59, 999_999_999).unwrap(); let max_time = NaiveTime::from_hms_nano(23, 59, 59, 999_999_999).unwrap();
assert_eq!(beyond_min.checked_add_months(Months::new(0)), Some(beyond_min)); assert_eq!(beyond_min.checked_add_months(Months::new(0)), Some(beyond_min));
assert_eq!( assert_eq!(
beyond_min.checked_add_months(Months::new(1)), beyond_min.checked_add_months(Months::new(1)),
Some(offset_min.from_utc_datetime(&(NaiveDate::MIN + Months(1)).and_time(NaiveTime::MIN))) Some(offset_min.from_utc_datetime((NaiveDate::MIN + Months(1)).and_time(NaiveTime::MIN)))
); );
assert_eq!(beyond_min.checked_sub_months(Months::new(0)), Some(beyond_min)); assert_eq!(beyond_min.checked_sub_months(Months::new(0)), Some(beyond_min));
assert_eq!(beyond_min.checked_sub_months(Months::new(1)), None); assert_eq!(beyond_min.checked_sub_months(Months::new(1)), None);
@ -1596,21 +1590,21 @@ fn test_min_max_add_months() {
assert_eq!(beyond_max.checked_sub_months(Months::new(0)), Some(beyond_max)); assert_eq!(beyond_max.checked_sub_months(Months::new(0)), Some(beyond_max));
assert_eq!( assert_eq!(
beyond_max.checked_sub_months(Months::new(1)), beyond_max.checked_sub_months(Months::new(1)),
Some(offset_max.from_utc_datetime(&(NaiveDate::MAX - Months(1)).and_time(max_time))) Some(offset_max.from_utc_datetime((NaiveDate::MAX - Months(1)).and_time(max_time)))
); );
} }
#[test] #[test]
#[should_panic] #[should_panic]
fn test_local_beyond_min_datetime() { fn test_local_beyond_min_datetime() {
let min = FixedOffset::west(2 * 60 * 60).unwrap().from_utc_datetime(&NaiveDateTime::MIN); let min = FixedOffset::west(2 * 60 * 60).unwrap().from_utc_datetime(NaiveDateTime::MIN);
let _ = min.naive_local(); let _ = min.naive_local();
} }
#[test] #[test]
#[should_panic] #[should_panic]
fn test_local_beyond_max_datetime() { fn test_local_beyond_max_datetime() {
let max = FixedOffset::east(2 * 60 * 60).unwrap().from_utc_datetime(&NaiveDateTime::MAX); let max = FixedOffset::east(2 * 60 * 60).unwrap().from_utc_datetime(NaiveDateTime::MAX);
let _ = max.naive_local(); let _ = max.naive_local();
} }
@ -1619,8 +1613,8 @@ fn test_local_beyond_max_datetime() {
fn test_datetime_sub_assign_local() { fn test_datetime_sub_assign_local() {
let naivedatetime = NaiveDate::from_ymd(2022, 1, 1).unwrap().and_hms(0, 0, 0).unwrap(); let naivedatetime = NaiveDate::from_ymd(2022, 1, 1).unwrap().and_hms(0, 0, 0).unwrap();
let datetime = Local.from_utc_datetime(&naivedatetime); let datetime = Local.from_utc_datetime(naivedatetime);
let mut datetime_sub = Local.from_utc_datetime(&naivedatetime); let mut datetime_sub = Local.from_utc_datetime(naivedatetime);
// ensure we cross a DST transition // ensure we cross a DST transition
for i in 1..=365 { for i in 1..=365 {
@ -1655,7 +1649,7 @@ fn test_core_duration_max() {
fn test_datetime_local_from_preserves_offset() { fn test_datetime_local_from_preserves_offset() {
let naivedatetime = NaiveDate::from_ymd(2023, 1, 1).unwrap().and_hms(0, 0, 0).unwrap(); let naivedatetime = NaiveDate::from_ymd(2023, 1, 1).unwrap().and_hms(0, 0, 0).unwrap();
let datetime = Local.from_utc_datetime(&naivedatetime); let datetime = Local.from_utc_datetime(naivedatetime);
let offset = datetime.offset().fix(); let offset = datetime.offset().fix();
let datetime_fixed: DateTime<FixedOffset> = datetime.into(); let datetime_fixed: DateTime<FixedOffset> = datetime.into();
@ -1667,12 +1661,12 @@ fn test_datetime_local_from_preserves_offset() {
fn test_datetime_fixed_offset() { fn test_datetime_fixed_offset() {
let naivedatetime = NaiveDate::from_ymd(2023, 1, 1).unwrap().and_hms(0, 0, 0).unwrap(); let naivedatetime = NaiveDate::from_ymd(2023, 1, 1).unwrap().and_hms(0, 0, 0).unwrap();
let datetime = Utc.from_utc_datetime(&naivedatetime); let datetime = Utc.from_utc_datetime(naivedatetime);
let fixed_utc = FixedOffset::east(0).unwrap(); let fixed_utc = FixedOffset::east(0).unwrap();
assert_eq!(datetime.fixed_offset(), fixed_utc.from_local_datetime(&naivedatetime).unwrap()); assert_eq!(datetime.fixed_offset(), fixed_utc.from_local_datetime(naivedatetime).unwrap());
let fixed_offset = FixedOffset::east(3600).unwrap(); let fixed_offset = FixedOffset::east(3600).unwrap();
let datetime_fixed = fixed_offset.from_local_datetime(&naivedatetime).unwrap(); let datetime_fixed = fixed_offset.from_local_datetime(naivedatetime).unwrap();
assert_eq!(datetime_fixed.fixed_offset(), datetime_fixed); assert_eq!(datetime_fixed.fixed_offset(), datetime_fixed);
} }

12
src/format/parsed.rs
View File

@ -858,7 +858,7 @@ impl Parsed {
let datetime = self.to_naive_datetime_with_offset(offset)?; let datetime = self.to_naive_datetime_with_offset(offset)?;
let offset = FixedOffset::east(offset).map_err(|_| OUT_OF_RANGE)?; let offset = FixedOffset::east(offset).map_err(|_| OUT_OF_RANGE)?;
match offset.from_local_datetime(&datetime) { match offset.from_local_datetime(datetime) {
MappedLocalTime::None => Err(IMPOSSIBLE), MappedLocalTime::None => Err(IMPOSSIBLE),
MappedLocalTime::Single(t) => Ok(t), MappedLocalTime::Single(t) => Ok(t),
MappedLocalTime::Ambiguous(..) => Err(NOT_ENOUGH), MappedLocalTime::Ambiguous(..) => Err(NOT_ENOUGH),
@ -899,7 +899,7 @@ impl Parsed {
let dt = DateTime::from_timestamp(timestamp, nanosecond) let dt = DateTime::from_timestamp(timestamp, nanosecond)
.map_err(|_| OUT_OF_RANGE)? .map_err(|_| OUT_OF_RANGE)?
.naive_utc(); .naive_utc();
guessed_offset = tz.offset_from_utc_datetime(&dt).fix().local_minus_utc(); guessed_offset = tz.offset_from_utc_datetime(dt).fix().local_minus_utc();
} }
// checks if the given `DateTime` has a consistent `Offset` with given `self.offset`. // checks if the given `DateTime` has a consistent `Offset` with given `self.offset`.
@ -914,7 +914,7 @@ impl Parsed {
// `guessed_offset` should be correct when `self.timestamp` is given. // `guessed_offset` should be correct when `self.timestamp` is given.
// it will be 0 otherwise, but this is fine as the algorithm ignores offset for that case. // it will be 0 otherwise, but this is fine as the algorithm ignores offset for that case.
let datetime = self.to_naive_datetime_with_offset(guessed_offset)?; let datetime = self.to_naive_datetime_with_offset(guessed_offset)?;
match tz.from_local_datetime(&datetime) { match tz.from_local_datetime(datetime) {
MappedLocalTime::None => Err(IMPOSSIBLE), MappedLocalTime::None => Err(IMPOSSIBLE),
MappedLocalTime::Single(t) => { MappedLocalTime::Single(t) => {
if check_offset(&t) { if check_offset(&t) {
@ -1656,7 +1656,7 @@ mod tests {
Ok(FixedOffset::east(off) Ok(FixedOffset::east(off)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(y, m, d).unwrap().and_hms_nano(h, n, s, nano).unwrap(), NaiveDate::from_ymd(y, m, d).unwrap().and_hms_nano(h, n, s, nano).unwrap(),
) )
.unwrap()) .unwrap())
}; };
@ -1704,7 +1704,7 @@ mod tests {
minute: 26, second: 40, nanosecond: 12_345_678, offset: 0), minute: 26, second: 40, nanosecond: 12_345_678, offset: 0),
Ok(Utc Ok(Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2014, 12, 31) NaiveDate::from_ymd(2014, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(4, 26, 40, 12_345_678) .and_hms_nano(4, 26, 40, 12_345_678)
.unwrap() .unwrap()
@ -1730,7 +1730,7 @@ mod tests {
Ok(FixedOffset::east(32400) Ok(FixedOffset::east(32400)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2014, 12, 31) NaiveDate::from_ymd(2014, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(13, 26, 40, 12_345_678) .and_hms_nano(13, 26, 40, 12_345_678)
.unwrap() .unwrap()

4
src/format/strftime.rs
View File

@ -853,7 +853,7 @@ mod tests {
let dt = FixedOffset::east(34200) let dt = FixedOffset::east(34200)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2001, 7, 8) NaiveDate::from_ymd(2001, 7, 8)
.unwrap() .unwrap()
.and_hms_nano(0, 34, 59, 1_026_490_708) .and_hms_nano(0, 34, 59, 1_026_490_708)
.unwrap(), .unwrap(),
@ -1021,7 +1021,7 @@ mod tests {
let dt = FixedOffset::east(34200) let dt = FixedOffset::east(34200)
.unwrap() .unwrap()
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2001, 7, 8) NaiveDate::from_ymd(2001, 7, 8)
.unwrap() .unwrap()
.and_hms_nano(0, 34, 59, 1_026_490_708) .and_hms_nano(0, 34, 59, 1_026_490_708)
.unwrap(), .unwrap(),

6
src/lib.rs
View File

@ -159,8 +159,8 @@
//! # #[cfg(feature = "clock")] { //! # #[cfg(feature = "clock")] {
//! // other time zone objects can be used to construct a local datetime. //! // other time zone objects can be used to construct a local datetime.
//! // obviously, `local_dt` is normally different from `dt`, but `fixed_dt` should be identical. //! // obviously, `local_dt` is normally different from `dt`, but `fixed_dt` should be identical.
//! let local_dt = Local.from_local_datetime(&NaiveDate::from_ymd(2014, 7, 8).unwrap().and_hms_milli(9, 10, 11, 12).unwrap()).unwrap(); //! let local_dt = Local.from_local_datetime(NaiveDate::from_ymd(2014, 7, 8).unwrap().and_hms_milli(9, 10, 11, 12).unwrap()).unwrap();
//! let fixed_dt = FixedOffset::east(9 * 3600).unwrap().from_local_datetime(&NaiveDate::from_ymd(2014, 7, 8).unwrap().and_hms_milli(18, 10, 11, 12).unwrap()).unwrap(); //! let fixed_dt = FixedOffset::east(9 * 3600).unwrap().from_local_datetime(NaiveDate::from_ymd(2014, 7, 8).unwrap().and_hms_milli(18, 10, 11, 12).unwrap()).unwrap();
//! assert_eq!(dt, fixed_dt); //! assert_eq!(dt, fixed_dt);
//! # let _ = local_dt; //! # let _ = local_dt;
//! # } //! # }
@ -179,7 +179,7 @@
//! use chrono::prelude::*; //! use chrono::prelude::*;
//! //!
//! // assume this returned `2014-11-28T21:45:59.324310806+09:00`: //! // assume this returned `2014-11-28T21:45:59.324310806+09:00`:
//! let dt = FixedOffset::east(9*3600).unwrap().from_local_datetime(&NaiveDate::from_ymd(2014, 11, 28).unwrap().and_hms_nano(21, 45, 59, 324310806).unwrap()).unwrap(); //! let dt = FixedOffset::east(9*3600).unwrap().from_local_datetime(NaiveDate::from_ymd(2014, 11, 28).unwrap().and_hms_nano(21, 45, 59, 324310806).unwrap()).unwrap();
//! //!
//! // property accessors //! // property accessors
//! assert_eq!((dt.year(), dt.month(), dt.day()), (2014, 11, 28)); //! assert_eq!((dt.year(), dt.month(), dt.day()), (2014, 11, 28));

2
src/naive/datetime/mod.rs
View File

@ -707,7 +707,7 @@ impl NaiveDateTime {
/// ``` /// ```
#[must_use] #[must_use]
pub fn and_local_timezone<Tz: TimeZone>(&self, tz: Tz) -> MappedLocalTime<DateTime<Tz>> { pub fn and_local_timezone<Tz: TimeZone>(&self, tz: Tz) -> MappedLocalTime<DateTime<Tz>> {
tz.from_local_datetime(self) tz.from_local_datetime(*self)
} }
/// Converts the `NaiveDateTime` into the timezone-aware `DateTime<Utc>`. /// Converts the `NaiveDateTime` into the timezone-aware `DateTime<Utc>`.

4
src/naive/time/mod.rs
View File

@ -193,12 +193,12 @@ mod tests;
/// let paramaribo_pre1945 = FixedOffset::east(-13236).unwrap(); // -03:40:36 /// let paramaribo_pre1945 = FixedOffset::east(-13236).unwrap(); // -03:40:36
/// let leap_sec_2015 = /// let leap_sec_2015 =
/// NaiveDate::from_ymd(2015, 6, 30).unwrap().and_hms_milli(23, 59, 59, 1_000).unwrap(); /// NaiveDate::from_ymd(2015, 6, 30).unwrap().and_hms_milli(23, 59, 59, 1_000).unwrap();
/// let dt1 = paramaribo_pre1945.from_utc_datetime(&leap_sec_2015); /// let dt1 = paramaribo_pre1945.from_utc_datetime(leap_sec_2015);
/// assert_eq!(format!("{:?}", dt1), "2015-06-30T20:19:24-03:40:36"); /// assert_eq!(format!("{:?}", dt1), "2015-06-30T20:19:24-03:40:36");
/// assert_eq!(format!("{:?}", dt1.time()), "20:19:24"); /// assert_eq!(format!("{:?}", dt1.time()), "20:19:24");
/// ///
/// let next_sec = NaiveDate::from_ymd(2015, 7, 1).unwrap().and_hms(0, 0, 0).unwrap(); /// let next_sec = NaiveDate::from_ymd(2015, 7, 1).unwrap().and_hms(0, 0, 0).unwrap();
/// let dt2 = paramaribo_pre1945.from_utc_datetime(&next_sec); /// let dt2 = paramaribo_pre1945.from_utc_datetime(next_sec);
/// assert_eq!(format!("{:?}", dt2), "2015-06-30T20:19:24-03:40:36"); /// assert_eq!(format!("{:?}", dt2), "2015-06-30T20:19:24-03:40:36");
/// assert_eq!(format!("{:?}", dt2.time()), "20:19:24"); /// assert_eq!(format!("{:?}", dt2.time()), "20:19:24");
/// ///

4
src/offset/fixed.rs
View File

@ -113,11 +113,11 @@ impl TimeZone for FixedOffset {
*offset *offset
} }
fn offset_from_local_datetime(&self, _local: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { fn offset_from_local_datetime(&self, _local: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
MappedLocalTime::Single(*self) MappedLocalTime::Single(*self)
} }
fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> FixedOffset { fn offset_from_utc_datetime(&self, _utc: NaiveDateTime) -> FixedOffset {
*self *self
} }
} }

26
src/offset/local/mod.rs
View File

@ -38,13 +38,13 @@ mod inner {
use crate::{FixedOffset, MappedLocalTime, NaiveDateTime}; use crate::{FixedOffset, MappedLocalTime, NaiveDateTime};
pub(super) fn offset_from_utc_datetime( pub(super) fn offset_from_utc_datetime(
_utc_time: &NaiveDateTime, _utc_time: NaiveDateTime,
) -> MappedLocalTime<FixedOffset> { ) -> MappedLocalTime<FixedOffset> {
MappedLocalTime::Single(FixedOffset::east(0).unwrap()) MappedLocalTime::Single(FixedOffset::east(0).unwrap())
} }
pub(super) fn offset_from_local_datetime( pub(super) fn offset_from_local_datetime(
_local_time: &NaiveDateTime, _local_time: NaiveDateTime,
) -> MappedLocalTime<FixedOffset> { ) -> MappedLocalTime<FixedOffset> {
MappedLocalTime::Single(FixedOffset::east(0).unwrap()) MappedLocalTime::Single(FixedOffset::east(0).unwrap())
} }
@ -58,14 +58,12 @@ mod inner {
mod inner { mod inner {
use crate::{Datelike, FixedOffset, MappedLocalTime, NaiveDateTime, Timelike}; use crate::{Datelike, FixedOffset, MappedLocalTime, NaiveDateTime, Timelike};
pub(super) fn offset_from_utc_datetime(utc: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { pub(super) fn offset_from_utc_datetime(utc: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
let offset = js_sys::Date::from(utc.and_utc()).get_timezone_offset(); let offset = js_sys::Date::from(utc.and_utc()).get_timezone_offset();
MappedLocalTime::Single(FixedOffset::west((offset as i32) * 60).unwrap()) MappedLocalTime::Single(FixedOffset::west((offset as i32) * 60).unwrap())
} }
pub(super) fn offset_from_local_datetime( pub(super) fn offset_from_local_datetime(local: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
local: &NaiveDateTime,
) -> MappedLocalTime<FixedOffset> {
let mut year = local.year(); let mut year = local.year();
if year < 100 { if year < 100 {
// The API in `js_sys` does not let us create a `Date` with negative years. // The API in `js_sys` does not let us create a `Date` with negative years.
@ -158,11 +156,11 @@ impl TimeZone for Local {
Local Local
} }
fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { fn offset_from_local_datetime(&self, local: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
inner::offset_from_local_datetime(local) inner::offset_from_local_datetime(local)
} }
fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> FixedOffset { fn offset_from_utc_datetime(&self, utc: NaiveDateTime) -> FixedOffset {
inner::offset_from_utc_datetime(utc).unwrap() inner::offset_from_utc_datetime(utc).unwrap()
} }
} }
@ -261,8 +259,8 @@ mod tests {
#[test] #[test]
fn verify_correct_offsets() { fn verify_correct_offsets() {
let now = Local::now(); let now = Local::now();
let from_local = Local.from_local_datetime(&now.naive_local()).unwrap(); let from_local = Local.from_local_datetime(now.naive_local()).unwrap();
let from_utc = Local.from_utc_datetime(&now.naive_utc()); let from_utc = Local.from_utc_datetime(now.naive_utc());
assert_eq!(now.offset().local_minus_utc(), from_local.offset().local_minus_utc()); assert_eq!(now.offset().local_minus_utc(), from_local.offset().local_minus_utc());
assert_eq!(now.offset().local_minus_utc(), from_utc.offset().local_minus_utc()); assert_eq!(now.offset().local_minus_utc(), from_utc.offset().local_minus_utc());
@ -274,8 +272,8 @@ mod tests {
#[test] #[test]
fn verify_correct_offsets_distant_past() { fn verify_correct_offsets_distant_past() {
let distant_past = Local::now() - Days::new(365 * 500); let distant_past = Local::now() - Days::new(365 * 500);
let from_local = Local.from_local_datetime(&distant_past.naive_local()).unwrap(); let from_local = Local.from_local_datetime(distant_past.naive_local()).unwrap();
let from_utc = Local.from_utc_datetime(&distant_past.naive_utc()); let from_utc = Local.from_utc_datetime(distant_past.naive_utc());
assert_eq!(distant_past.offset().local_minus_utc(), from_local.offset().local_minus_utc()); assert_eq!(distant_past.offset().local_minus_utc(), from_local.offset().local_minus_utc());
assert_eq!(distant_past.offset().local_minus_utc(), from_utc.offset().local_minus_utc()); assert_eq!(distant_past.offset().local_minus_utc(), from_utc.offset().local_minus_utc());
@ -287,8 +285,8 @@ mod tests {
#[test] #[test]
fn verify_correct_offsets_distant_future() { fn verify_correct_offsets_distant_future() {
let distant_future = Local::now() + Days::new(365 * 35000); let distant_future = Local::now() + Days::new(365 * 35000);
let from_local = Local.from_local_datetime(&distant_future.naive_local()).unwrap(); let from_local = Local.from_local_datetime(distant_future.naive_local()).unwrap();
let from_utc = Local.from_utc_datetime(&distant_future.naive_utc()); let from_utc = Local.from_utc_datetime(distant_future.naive_utc());
assert_eq!( assert_eq!(
distant_future.offset().local_minus_utc(), distant_future.offset().local_minus_utc(),

8
src/offset/local/unix.rs
View File

@ -14,17 +14,17 @@ use super::tz_info::TimeZone;
use super::{FixedOffset, NaiveDateTime}; use super::{FixedOffset, NaiveDateTime};
use crate::{Datelike, MappedLocalTime}; use crate::{Datelike, MappedLocalTime};
pub(super) fn offset_from_utc_datetime(utc: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { pub(super) fn offset_from_utc_datetime(utc: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
offset(utc, false) offset(utc, false)
} }
pub(super) fn offset_from_local_datetime(local: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { pub(super) fn offset_from_local_datetime(local: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
offset(local, true) offset(local, true)
} }
fn offset(d: &NaiveDateTime, local: bool) -> MappedLocalTime<FixedOffset> { fn offset(d: NaiveDateTime, local: bool) -> MappedLocalTime<FixedOffset> {
TZ_INFO.with(|maybe_cache| { TZ_INFO.with(|maybe_cache| {
maybe_cache.borrow_mut().get_or_insert_with(Cache::default).offset(*d, local) maybe_cache.borrow_mut().get_or_insert_with(Cache::default).offset(d, local)
}) })
} }

28
src/offset/local/windows.rs
View File

@ -26,7 +26,7 @@ use crate::{
// This method uses `overflowing_sub_offset` because it is no problem if the transition time in UTC // This method uses `overflowing_sub_offset` because it is no problem if the transition time in UTC
// falls a couple of hours inside the buffer space around the `NaiveDateTime` range (although it is // falls a couple of hours inside the buffer space around the `NaiveDateTime` range (although it is
// very theoretical to have a transition at midnight around `NaiveDate::(MIN|MAX)`. // very theoretical to have a transition at midnight around `NaiveDate::(MIN|MAX)`.
pub(super) fn offset_from_utc_datetime(utc: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { pub(super) fn offset_from_utc_datetime(utc: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
// Using a `TzInfo` based on the year of an UTC datetime is technically wrong, we should be // Using a `TzInfo` based on the year of an UTC datetime is technically wrong, we should be
// using the rules for the year of the corresponding local time. But this matches what // using the rules for the year of the corresponding local time. But this matches what
// `SystemTimeToTzSpecificLocalTime` is documented to do. // `SystemTimeToTzSpecificLocalTime` is documented to do.
@ -39,12 +39,12 @@ pub(super) fn offset_from_utc_datetime(utc: &NaiveDateTime) -> MappedLocalTime<F
let std_transition_utc = std_transition.overflowing_sub_offset(tz_info.dst_offset); let std_transition_utc = std_transition.overflowing_sub_offset(tz_info.dst_offset);
let dst_transition_utc = dst_transition.overflowing_sub_offset(tz_info.std_offset); let dst_transition_utc = dst_transition.overflowing_sub_offset(tz_info.std_offset);
if dst_transition_utc < std_transition_utc { if dst_transition_utc < std_transition_utc {
match utc >= &dst_transition_utc && utc < &std_transition_utc { match utc >= dst_transition_utc && utc < std_transition_utc {
true => tz_info.dst_offset, true => tz_info.dst_offset,
false => tz_info.std_offset, false => tz_info.std_offset,
} }
} else { } else {
match utc >= &std_transition_utc && utc < &dst_transition_utc { match utc >= std_transition_utc && utc < dst_transition_utc {
true => tz_info.std_offset, true => tz_info.std_offset,
false => tz_info.dst_offset, false => tz_info.dst_offset,
} }
@ -52,14 +52,14 @@ pub(super) fn offset_from_utc_datetime(utc: &NaiveDateTime) -> MappedLocalTime<F
} }
(Some(std_transition), None) => { (Some(std_transition), None) => {
let std_transition_utc = std_transition.overflowing_sub_offset(tz_info.dst_offset); let std_transition_utc = std_transition.overflowing_sub_offset(tz_info.dst_offset);
match utc < &std_transition_utc { match utc < std_transition_utc {
true => tz_info.dst_offset, true => tz_info.dst_offset,
false => tz_info.std_offset, false => tz_info.std_offset,
} }
} }
(None, Some(dst_transition)) => { (None, Some(dst_transition)) => {
let dst_transition_utc = dst_transition.overflowing_sub_offset(tz_info.std_offset); let dst_transition_utc = dst_transition.overflowing_sub_offset(tz_info.std_offset);
match utc < &dst_transition_utc { match utc < dst_transition_utc {
true => tz_info.std_offset, true => tz_info.std_offset,
false => tz_info.dst_offset, false => tz_info.dst_offset,
} }
@ -72,7 +72,7 @@ pub(super) fn offset_from_utc_datetime(utc: &NaiveDateTime) -> MappedLocalTime<F
// We don't use `TzSpecificLocalTimeToSystemTime` because it doesn't let us choose how to handle // We don't use `TzSpecificLocalTimeToSystemTime` because it doesn't let us choose how to handle
// ambiguous cases (during a DST transition). Instead we get the timezone information for the // ambiguous cases (during a DST transition). Instead we get the timezone information for the
// current year and compute it ourselves, like we do on Unix. // current year and compute it ourselves, like we do on Unix.
pub(super) fn offset_from_local_datetime(local: &NaiveDateTime) -> MappedLocalTime<FixedOffset> { pub(super) fn offset_from_local_datetime(local: NaiveDateTime) -> MappedLocalTime<FixedOffset> {
let tz_info = match TzInfo::for_year(local.year()) { let tz_info = match TzInfo::for_year(local.year()) {
Some(tz_info) => tz_info, Some(tz_info) => tz_info,
None => return MappedLocalTime::None, None => return MappedLocalTime::None,
@ -92,17 +92,17 @@ pub(super) fn offset_from_local_datetime(local: &NaiveDateTime) -> MappedLocalTi
return MappedLocalTime::Single(tz_info.std_offset); return MappedLocalTime::Single(tz_info.std_offset);
} }
}; };
lookup_with_dst_transitions(&transitions, *local) lookup_with_dst_transitions(&transitions, local)
} }
(Some(std_transition), None) => { (Some(std_transition), None) => {
let transitions = let transitions =
[Transition::new(std_transition, tz_info.dst_offset, tz_info.std_offset)]; [Transition::new(std_transition, tz_info.dst_offset, tz_info.std_offset)];
lookup_with_dst_transitions(&transitions, *local) lookup_with_dst_transitions(&transitions, local)
} }
(None, Some(dst_transition)) => { (None, Some(dst_transition)) => {
let transitions = let transitions =
[Transition::new(dst_transition, tz_info.std_offset, tz_info.dst_offset)]; [Transition::new(dst_transition, tz_info.std_offset, tz_info.dst_offset)];
lookup_with_dst_transitions(&transitions, *local) lookup_with_dst_transitions(&transitions, local)
} }
(None, None) => MappedLocalTime::Single(tz_info.std_offset), (None, None) => MappedLocalTime::Single(tz_info.std_offset),
} }
@ -233,16 +233,16 @@ mod tests {
// implementation to `TzSpecificLocalTimeToSystemTime`. // implementation to `TzSpecificLocalTimeToSystemTime`.
// //
// This uses parts of a previous Windows `Local` implementation in chrono. // This uses parts of a previous Windows `Local` implementation in chrono.
fn from_local_time(dt: &NaiveDateTime) -> DateTime<Local> { fn from_local_time(dt: NaiveDateTime) -> DateTime<Local> {
let st = system_time_from_naive_date_time(dt); let st = system_time_from_naive_date_time(dt);
let utc_time = local_to_utc_time(&st); let utc_time = local_to_utc_time(&st);
let utc_secs = system_time_as_unix_seconds(&utc_time); let utc_secs = system_time_as_unix_seconds(&utc_time);
let local_secs = system_time_as_unix_seconds(&st); let local_secs = system_time_as_unix_seconds(&st);
let offset = (local_secs - utc_secs) as i32; let offset = (local_secs - utc_secs) as i32;
let offset = FixedOffset::east(offset).unwrap(); let offset = FixedOffset::east(offset).unwrap();
DateTime::from_naive_utc_and_offset(*dt - offset, offset) DateTime::from_naive_utc_and_offset(dt - offset, offset)
} }
fn system_time_from_naive_date_time(dt: &NaiveDateTime) -> SYSTEMTIME { fn system_time_from_naive_date_time(dt: NaiveDateTime) -> SYSTEMTIME {
SYSTEMTIME { SYSTEMTIME {
// Valid values: 1601-30827 // Valid values: 1601-30827
wYear: dt.year() as u16, wYear: dt.year() as u16,
@ -290,8 +290,8 @@ mod tests {
while date.year() < 2078 { while date.year() < 2078 {
// Windows doesn't handle non-existing dates, it just treats it as valid. // Windows doesn't handle non-existing dates, it just treats it as valid.
if let Some(our_result) = Local.from_local_datetime(&date).earliest() { if let Some(our_result) = Local.from_local_datetime(date).earliest() {
assert_eq!(from_local_time(&date), our_result); assert_eq!(from_local_time(date), our_result);
} }
date += TimeDelta::hours(1); date += TimeDelta::hours(1);
} }

28
src/offset/mod.rs
View File

@ -165,7 +165,7 @@ pub trait TimeZone: Sized + Clone {
sec: u32, sec: u32,
) -> MappedLocalTime<DateTime<Self>> { ) -> MappedLocalTime<DateTime<Self>> {
match NaiveDate::from_ymd(year, month, day).and_then(|d| d.and_hms(hour, min, sec)) { match NaiveDate::from_ymd(year, month, day).and_then(|d| d.and_hms(hour, min, sec)) {
Ok(dt) => self.from_local_datetime(&dt), Ok(dt) => self.from_local_datetime(dt),
Err(_) => MappedLocalTime::None, Err(_) => MappedLocalTime::None,
} }
} }
@ -192,7 +192,7 @@ pub trait TimeZone: Sized + Clone {
/// ``` /// ```
fn timestamp(&self, secs: i64, nsecs: u32) -> MappedLocalTime<DateTime<Self>> { fn timestamp(&self, secs: i64, nsecs: u32) -> MappedLocalTime<DateTime<Self>> {
match DateTime::from_timestamp(secs, nsecs) { match DateTime::from_timestamp(secs, nsecs) {
Ok(dt) => MappedLocalTime::Single(self.from_utc_datetime(&dt.naive_utc())), Ok(dt) => MappedLocalTime::Single(self.from_utc_datetime(dt.naive_utc())),
Err(_) => MappedLocalTime::None, Err(_) => MappedLocalTime::None,
} }
} }
@ -216,7 +216,7 @@ pub trait TimeZone: Sized + Clone {
/// ``` /// ```
fn timestamp_millis(&self, millis: i64) -> MappedLocalTime<DateTime<Self>> { fn timestamp_millis(&self, millis: i64) -> MappedLocalTime<DateTime<Self>> {
match DateTime::from_timestamp_millis(millis) { match DateTime::from_timestamp_millis(millis) {
Ok(dt) => MappedLocalTime::Single(self.from_utc_datetime(&dt.naive_utc())), Ok(dt) => MappedLocalTime::Single(self.from_utc_datetime(dt.naive_utc())),
Err(_) => MappedLocalTime::None, Err(_) => MappedLocalTime::None,
} }
} }
@ -234,7 +234,7 @@ pub trait TimeZone: Sized + Clone {
/// assert_eq!(Utc.timestamp_nanos(1431648000000000).timestamp(), 1431648); /// assert_eq!(Utc.timestamp_nanos(1431648000000000).timestamp(), 1431648);
/// ``` /// ```
fn timestamp_nanos(&self, nanos: i64) -> DateTime<Self> { fn timestamp_nanos(&self, nanos: i64) -> DateTime<Self> {
self.from_utc_datetime(&DateTime::from_timestamp_nanos(nanos).naive_utc()) self.from_utc_datetime(DateTime::from_timestamp_nanos(nanos).naive_utc())
} }
/// Makes a new `DateTime` from the number of non-leap microseconds /// Makes a new `DateTime` from the number of non-leap microseconds
@ -249,7 +249,7 @@ pub trait TimeZone: Sized + Clone {
/// ``` /// ```
fn timestamp_micros(&self, micros: i64) -> MappedLocalTime<DateTime<Self>> { fn timestamp_micros(&self, micros: i64) -> MappedLocalTime<DateTime<Self>> {
match DateTime::from_timestamp_micros(micros) { match DateTime::from_timestamp_micros(micros) {
Ok(dt) => MappedLocalTime::Single(self.from_utc_datetime(&dt.naive_utc())), Ok(dt) => MappedLocalTime::Single(self.from_utc_datetime(dt.naive_utc())),
Err(_) => MappedLocalTime::None, Err(_) => MappedLocalTime::None,
} }
} }
@ -258,11 +258,11 @@ pub trait TimeZone: Sized + Clone {
fn from_offset(offset: &Self::Offset) -> Self; fn from_offset(offset: &Self::Offset) -> Self;
/// Creates the offset(s) for given local `NaiveDateTime` if possible. /// Creates the offset(s) for given local `NaiveDateTime` if possible.
fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> MappedLocalTime<Self::Offset>; fn offset_from_local_datetime(&self, local: NaiveDateTime) -> MappedLocalTime<Self::Offset>;
/// Converts the local `NaiveDateTime` to the timezone-aware `DateTime` if possible. /// Converts the local `NaiveDateTime` to the timezone-aware `DateTime` if possible.
#[allow(clippy::wrong_self_convention)] #[allow(clippy::wrong_self_convention)]
fn from_local_datetime(&self, local: &NaiveDateTime) -> MappedLocalTime<DateTime<Self>> { fn from_local_datetime(&self, local: NaiveDateTime) -> MappedLocalTime<DateTime<Self>> {
// Return `MappedLocalTime::None` when the offset pushes a value out of range, instead of // Return `MappedLocalTime::None` when the offset pushes a value out of range, instead of
// panicking. // panicking.
match self.offset_from_local_datetime(local) { match self.offset_from_local_datetime(local) {
@ -284,13 +284,13 @@ pub trait TimeZone: Sized + Clone {
} }
/// Creates the offset for given UTC `NaiveDateTime`. This cannot fail. /// Creates the offset for given UTC `NaiveDateTime`. This cannot fail.
fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset; fn offset_from_utc_datetime(&self, utc: NaiveDateTime) -> Self::Offset;
/// Converts the UTC `NaiveDateTime` to the local time. /// Converts the UTC `NaiveDateTime` to the local time.
/// The UTC is continuous and thus this cannot fail (but can give the duplicate local time). /// The UTC is continuous and thus this cannot fail (but can give the duplicate local time).
#[allow(clippy::wrong_self_convention)] #[allow(clippy::wrong_self_convention)]
fn from_utc_datetime(&self, utc: &NaiveDateTime) -> DateTime<Self> { fn from_utc_datetime(&self, utc: NaiveDateTime) -> DateTime<Self> {
DateTime::from_naive_utc_and_offset(*utc, self.offset_from_utc_datetime(utc)) DateTime::from_naive_utc_and_offset(utc, self.offset_from_utc_datetime(utc))
} }
} }
@ -304,18 +304,18 @@ mod tests {
dbg!(offset_hour); dbg!(offset_hour);
let offset = FixedOffset::east(offset_hour * 60 * 60).unwrap(); let offset = FixedOffset::east(offset_hour * 60 * 60).unwrap();
let local_max = offset.from_utc_datetime(&NaiveDateTime::MAX); let local_max = offset.from_utc_datetime(NaiveDateTime::MAX);
assert_eq!(local_max.naive_utc(), NaiveDateTime::MAX); assert_eq!(local_max.naive_utc(), NaiveDateTime::MAX);
let local_min = offset.from_utc_datetime(&NaiveDateTime::MIN); let local_min = offset.from_utc_datetime(NaiveDateTime::MIN);
assert_eq!(local_min.naive_utc(), NaiveDateTime::MIN); assert_eq!(local_min.naive_utc(), NaiveDateTime::MIN);
let local_max = offset.from_local_datetime(&NaiveDateTime::MAX); let local_max = offset.from_local_datetime(NaiveDateTime::MAX);
if offset_hour >= 0 { if offset_hour >= 0 {
assert_eq!(local_max.unwrap().naive_local(), NaiveDateTime::MAX); assert_eq!(local_max.unwrap().naive_local(), NaiveDateTime::MAX);
} else { } else {
assert_eq!(local_max, MappedLocalTime::None); assert_eq!(local_max, MappedLocalTime::None);
} }
let local_min = offset.from_local_datetime(&NaiveDateTime::MIN); let local_min = offset.from_local_datetime(NaiveDateTime::MIN);
if offset_hour <= 0 { if offset_hour <= 0 {
assert_eq!(local_min.unwrap().naive_local(), NaiveDateTime::MIN); assert_eq!(local_min.unwrap().naive_local(), NaiveDateTime::MIN);
} else { } else {

4
src/offset/utc.rs
View File

@ -114,11 +114,11 @@ impl TimeZone for Utc {
Utc Utc
} }
fn offset_from_local_datetime(&self, _local: &NaiveDateTime) -> MappedLocalTime<Utc> { fn offset_from_local_datetime(&self, _local: NaiveDateTime) -> MappedLocalTime<Utc> {
MappedLocalTime::Single(Utc) MappedLocalTime::Single(Utc)
} }
fn offset_from_utc_datetime(&self, _utc: &NaiveDateTime) -> Utc { fn offset_from_utc_datetime(&self, _utc: NaiveDateTime) -> Utc {
Utc Utc
} }
} }

36
src/round.rs
View File

@ -320,7 +320,7 @@ mod tests {
let pst = FixedOffset::east(8 * 60 * 60).unwrap(); let pst = FixedOffset::east(8 * 60 * 60).unwrap();
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11) NaiveDate::from_ymd(2018, 1, 11)
.unwrap() .unwrap()
.and_hms_nano(10, 5, 13, 84_660_684) .and_hms_nano(10, 5, 13, 84_660_684)
.unwrap(), .unwrap(),
@ -343,7 +343,7 @@ mod tests {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11) NaiveDate::from_ymd(2018, 1, 11)
.unwrap() .unwrap()
.and_hms_nano(10, 5, 27, 750_500_000) .and_hms_nano(10, 5, 27, 750_500_000)
.unwrap(), .unwrap(),
@ -363,7 +363,7 @@ mod tests {
fn test_round_leap_nanos() { fn test_round_leap_nanos() {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2016, 12, 31) NaiveDate::from_ymd(2016, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(23, 59, 59, 1_750_500_000) .and_hms_nano(23, 59, 59, 1_750_500_000)
.unwrap(), .unwrap(),
@ -384,7 +384,7 @@ mod tests {
let pst = FixedOffset::east(8 * 60 * 60).unwrap(); let pst = FixedOffset::east(8 * 60 * 60).unwrap();
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11) NaiveDate::from_ymd(2018, 1, 11)
.unwrap() .unwrap()
.and_hms_nano(10, 5, 13, 84_660_684) .and_hms_nano(10, 5, 13, 84_660_684)
.unwrap(), .unwrap(),
@ -407,7 +407,7 @@ mod tests {
let dt = pst let dt = pst
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2018, 1, 11) NaiveDate::from_ymd(2018, 1, 11)
.unwrap() .unwrap()
.and_hms_nano(10, 5, 27, 750_500_000) .and_hms_nano(10, 5, 27, 750_500_000)
.unwrap(), .unwrap(),
@ -427,7 +427,7 @@ mod tests {
fn test_trunc_leap_nanos() { fn test_trunc_leap_nanos() {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2016, 12, 31) NaiveDate::from_ymd(2016, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(23, 59, 59, 1_750_500_000) .and_hms_nano(23, 59, 59, 1_750_500_000)
.unwrap(), .unwrap(),
@ -447,7 +447,7 @@ mod tests {
fn test_duration_round() { fn test_duration_round() {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2016, 12, 31) NaiveDate::from_ymd(2016, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(23, 59, 59, 175_500_000) .and_hms_nano(23, 59, 59, 175_500_000)
.unwrap(), .unwrap(),
@ -467,7 +467,7 @@ mod tests {
// round up // round up
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(),
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
@ -477,7 +477,7 @@ mod tests {
// round down // round down
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(),
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
@ -529,7 +529,7 @@ mod tests {
fn test_duration_round_naive() { fn test_duration_round_naive() {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2016, 12, 31) NaiveDate::from_ymd(2016, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(23, 59, 59, 175_500_000) .and_hms_nano(23, 59, 59, 175_500_000)
.unwrap(), .unwrap(),
@ -550,7 +550,7 @@ mod tests {
// round up // round up
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(),
) )
.unwrap() .unwrap()
.naive_utc(); .naive_utc();
@ -561,7 +561,7 @@ mod tests {
// round down // round down
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(),
) )
.unwrap() .unwrap()
.naive_utc(); .naive_utc();
@ -601,7 +601,7 @@ mod tests {
fn test_duration_trunc() { fn test_duration_trunc() {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2016, 12, 31) NaiveDate::from_ymd(2016, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(23, 59, 59, 175_500_000) .and_hms_nano(23, 59, 59, 175_500_000)
.unwrap(), .unwrap(),
@ -616,7 +616,7 @@ mod tests {
// would round up // would round up
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(),
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
@ -626,7 +626,7 @@ mod tests {
// would round down // would round down
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(),
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
@ -677,7 +677,7 @@ mod tests {
fn test_duration_trunc_naive() { fn test_duration_trunc_naive() {
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2016, 12, 31) NaiveDate::from_ymd(2016, 12, 31)
.unwrap() .unwrap()
.and_hms_nano(23, 59, 59, 175_500_000) .and_hms_nano(23, 59, 59, 175_500_000)
.unwrap(), .unwrap(),
@ -693,7 +693,7 @@ mod tests {
// would round up // would round up
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 30, 0).unwrap(),
) )
.unwrap() .unwrap()
.naive_utc(); .naive_utc();
@ -704,7 +704,7 @@ mod tests {
// would round down // would round down
let dt = Utc let dt = Utc
.from_local_datetime( .from_local_datetime(
&NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(), NaiveDate::from_ymd(2012, 12, 12).unwrap().and_hms_milli(18, 22, 29, 999).unwrap(),
) )
.unwrap() .unwrap()
.naive_utc(); .naive_utc();

4
tests/dateutils.rs
View File

@ -33,7 +33,7 @@ fn verify_against_date_command_local(path: &'static str, dt: NaiveDateTime) {
// differently // differently
let date = NaiveDate::from_ymd(dt.year(), dt.month(), dt.day()).unwrap(); let date = NaiveDate::from_ymd(dt.year(), dt.month(), dt.day()).unwrap();
match Local.from_local_datetime(&date.and_hms(dt.hour(), 5, 1).unwrap()) { match Local.from_local_datetime(date.and_hms(dt.hour(), 5, 1).unwrap()) {
chrono::MappedLocalTime::Ambiguous(a, b) => assert!( chrono::MappedLocalTime::Ambiguous(a, b) => assert!(
format!("{}\n", a) == date_command_str || format!("{}\n", b) == date_command_str format!("{}\n", a) == date_command_str || format!("{}\n", b) == date_command_str
), ),
@ -139,7 +139,7 @@ fn verify_against_date_command_format_local(path: &'static str, dt: NaiveDateTim
let date_command_str = String::from_utf8(output.stdout).unwrap(); let date_command_str = String::from_utf8(output.stdout).unwrap();
let date = NaiveDate::from_ymd(dt.year(), dt.month(), dt.day()).unwrap(); let date = NaiveDate::from_ymd(dt.year(), dt.month(), dt.day()).unwrap();
let ldt = Local let ldt = Local
.from_local_datetime(&date.and_hms(dt.hour(), dt.minute(), dt.second()).unwrap()) .from_local_datetime(date.and_hms(dt.hour(), dt.minute(), dt.second()).unwrap())
.unwrap(); .unwrap();
let formated_date = format!("{}\n", ldt.format(required_format)); let formated_date = format!("{}\n", ldt.format(required_format));
assert_eq!(date_command_str, formated_date); assert_eq!(date_command_str, formated_date);

2
tests/wasm.rs
View File

@ -67,7 +67,7 @@ fn from_is_exact() {
fn local_from_local_datetime() { fn local_from_local_datetime() {
let now = Local::now(); let now = Local::now();
let ndt = now.naive_local(); let ndt = now.naive_local();
let res = match Local.from_local_datetime(&ndt).single() { let res = match Local.from_local_datetime(ndt).single() {
Some(v) => v, Some(v) => v,
None => panic! {"Required for test!"}, None => panic! {"Required for test!"},
}; };