Implement a builder API for Now (#296)

This PR implements a builder API for now and closes #249.

It has some notable changes to the approach to `Now`.

Mainly `Now` is essentially cannot be built without using the new
`NowBuilder` and any method called on `Now` consumes it.

For general purpose, a `Temporal` namespace struct was created with
`now` and `try_now` methods, which uses the `NowBuilder` to construct a
`Now` with values from the system.

This does differ a bit from the specification in that we are eagerly
calling the host system time zone, rather than lazily when the user time
zone is `None`. But I think this can still be worked around on the
engine side if lazily calling is preferred and is more a place where the
native Rust API will differ from the engine implementation. The work
around to this is a trait based approach that is available to see on the
`now-builder` branch, but I think this a simpler and cleaner approach
than leaning on traits.

List of changes:

- `Now` updated and `NowBuilder` added.
- Feature flagged `Temporal` struct
- `time` module renamed to `unix_time`

Author: nekevss

src/builtins/compiled/now.rs

@@ -1,52 +1,40 @@
-#![cfg(feature = "sys")]
-
 use crate::builtins::{
     core::{Now, PlainDate, PlainDateTime, PlainTime},
     TZ_PROVIDER,
 };
-use crate::sys;
-use crate::{time::EpochNanoseconds, TemporalError, TemporalResult, TimeZone};
+use crate::{TemporalError, TemporalResult, TimeZone};
 
 impl Now {
     /// Returns the current system time as a [`PlainDateTime`] with an optional
     /// [`TimeZone`].
     ///
     /// Enable with the `compiled_data` and `sys` feature flags.
-    pub fn plain_datetime_iso(timezone: Option<TimeZone>) -> TemporalResult<PlainDateTime> {
+    pub fn plain_date_time_iso(self, time_zone: Option<TimeZone>) -> TemporalResult<PlainDateTime> {
         let provider = TZ_PROVIDER
             .lock()
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
-        let timezone = timezone.unwrap_or(TimeZone::IanaIdentifier(sys::get_system_timezone()?));
-        let system_nanos = sys::get_system_nanoseconds()?;
-        let epoch_nanos = EpochNanoseconds::try_from(system_nanos)?;
-        Now::plain_datetime_iso_with_provider_and_system_info(epoch_nanos, timezone, &*provider)
+        self.plain_date_time_iso_with_provider(time_zone, &*provider)
     }
 
     /// Returns the current system time as a [`PlainDate`] with an optional
     /// [`TimeZone`].
     ///
     /// Enable with the `compiled_data` and `sys` feature flags.
-    pub fn plain_date_iso(timezone: Option<TimeZone>) -> TemporalResult<PlainDate> {
+    pub fn plain_date_iso(self, time_zone: Option<TimeZone>) -> TemporalResult<PlainDate> {
         let provider = TZ_PROVIDER
             .lock()
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
-        let timezone = timezone.unwrap_or(TimeZone::IanaIdentifier(sys::get_system_timezone()?));
-        let system_nanos = sys::get_system_nanoseconds()?;
-        let epoch_nanos = EpochNanoseconds::try_from(system_nanos)?;
-        Now::plain_date_iso_with_provider_and_system_info(epoch_nanos, timezone, &*provider)
+        self.plain_date_iso_with_provider(time_zone, &*provider)
     }
 
     /// Returns the current system time as a [`PlainTime`] with an optional
     /// [`TimeZone`].
     ///
     /// Enable with the `compiled_data` and `sys` feature flags.
-    pub fn plain_time_iso(timezone: Option<TimeZone>) -> TemporalResult<PlainTime> {
+    pub fn plain_time_iso(self, time_zone: Option<TimeZone>) -> TemporalResult<PlainTime> {
         let provider = TZ_PROVIDER
             .lock()
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
-        let timezone = timezone.unwrap_or(TimeZone::IanaIdentifier(sys::get_system_timezone()?));
-        let system_nanos = sys::get_system_nanoseconds()?;
-        let epoch_nanos = EpochNanoseconds::try_from(system_nanos)?;
-        Now::plain_time_iso_with_provider_and_system_info(epoch_nanos, timezone, &*provider)
+        self.plain_time_with_provider(time_zone, &*provider)
     }
 }

src/builtins/core/instant.rs

@@ -15,7 +15,7 @@ use crate::{
     parsers::{parse_instant, IxdtfStringBuilder},
     provider::TimeZoneProvider,
     rounding::{IncrementRounder, Round},
-    time::EpochNanoseconds,
+    unix_time::EpochNanoseconds,
     Calendar, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
 };
 
@@ -335,7 +335,7 @@ mod tests {
     use crate::{
         builtins::core::{duration::TimeDuration, Instant},
         options::{DifferenceSettings, RoundingMode, Unit},
-        time::EpochNanoseconds,
+        unix_time::EpochNanoseconds,
         NS_MAX_INSTANT, NS_MIN_INSTANT,
     };
 

src/builtins/core/mod.rs

@@ -21,7 +21,7 @@ pub(crate) mod zoneddatetime;
 mod now;
 
 #[doc(inline)]
-pub use now::Now;
+pub use now::{Now, NowBuilder};
 
 #[doc(inline)]
 pub use date::{PartialDate, PlainDate};