jiff/fmt/temporal/
printer.rs

Help
1use crate::{
2    civil::{Date, DateTime, Time},
3    error::{err, Error},
4    fmt::{
5        temporal::{Pieces, PiecesOffset, TimeZoneAnnotationKind},
6        util::{DecimalFormatter, FractionalFormatter},
7        Write, WriteExt,
8    },
9    span::Span,
10    tz::{Offset, TimeZone},
11    util::{
12        rangeint::RFrom,
13        t::{self, C},
14    },
15    SignedDuration, Timestamp, Zoned,
16};
17
18#[derive(Clone, Debug)]
19pub(super) struct DateTimePrinter {
20    lowercase: bool,
21    separator: u8,
22    rfc9557: bool,
23    precision: Option<u8>,
24}
25
26impl DateTimePrinter {
27    pub(super) const fn new() -> DateTimePrinter {
28        DateTimePrinter {
29            lowercase: false,
30            separator: b'T',
31            rfc9557: true,
32            precision: None,
33        }
34    }
35
36    pub(super) const fn lowercase(self, yes: bool) -> DateTimePrinter {
37        DateTimePrinter { lowercase: yes, ..self }
38    }
39
40    pub(super) const fn separator(self, ascii_char: u8) -> DateTimePrinter {
41        assert!(ascii_char.is_ascii(), "RFC3339 separator must be ASCII");
42        DateTimePrinter { separator: ascii_char, ..self }
43    }
44
45    pub(super) const fn precision(
46        self,
47        precision: Option<u8>,
48    ) -> DateTimePrinter {
49        DateTimePrinter { precision, ..self }
50    }
51
52    pub(super) fn print_zoned<W: Write>(
53        &self,
54        zdt: &Zoned,
55        mut wtr: W,
56    ) -> Result<(), Error> {
57        let timestamp = zdt.timestamp();
58        let tz = zdt.time_zone();
59        let offset = tz.to_offset(timestamp);
60        let dt = offset.to_datetime(timestamp);
61        self.print_datetime(&dt, &mut wtr)?;
62        if tz.is_unknown() {
63            wtr.write_str("Z[Etc/Unknown]")?;
64        } else {
65            self.print_offset_rounded(&offset, &mut wtr)?;
66            self.print_time_zone_annotation(&tz, &offset, &mut wtr)?;
67        }
68        Ok(())
69    }
70
71    pub(super) fn print_timestamp<W: Write>(
72        &self,
73        timestamp: &Timestamp,
74        offset: Option<Offset>,
75        mut wtr: W,
76    ) -> Result<(), Error> {
77        let Some(offset) = offset else {
78            let dt = TimeZone::UTC.to_datetime(*timestamp);
79            self.print_datetime(&dt, &mut wtr)?;
80            self.print_zulu(&mut wtr)?;
81            return Ok(());
82        };
83        let dt = offset.to_datetime(*timestamp);
84        self.print_datetime(&dt, &mut wtr)?;
85        self.print_offset_rounded(&offset, &mut wtr)?;
86        Ok(())
87    }
88
89    /// Formats the given datetime into the writer given.
90    pub(super) fn print_datetime<W: Write>(
91        &self,
92        dt: &DateTime,
93        mut wtr: W,
94    ) -> Result<(), Error> {
95        self.print_date(&dt.date(), &mut wtr)?;
96        wtr.write_char(char::from(if self.lowercase {
97            self.separator.to_ascii_lowercase()
98        } else {
99            self.separator
100        }))?;
101        self.print_time(&dt.time(), &mut wtr)?;
102        Ok(())
103    }
104
105    /// Formats the given date into the writer given.
106    pub(super) fn print_date<W: Write>(
107        &self,
108        date: &Date,
109        mut wtr: W,
110    ) -> Result<(), Error> {
111        static FMT_YEAR_POSITIVE: DecimalFormatter =
112            DecimalFormatter::new().padding(4);
113        static FMT_YEAR_NEGATIVE: DecimalFormatter =
114            DecimalFormatter::new().padding(6);
115        static FMT_TWO: DecimalFormatter = DecimalFormatter::new().padding(2);
116
117        if date.year() >= 0 {
118            wtr.write_int(&FMT_YEAR_POSITIVE, date.year())?;
119        } else {
120            wtr.write_int(&FMT_YEAR_NEGATIVE, date.year())?;
121        }
122        wtr.write_str("-")?;
123        wtr.write_int(&FMT_TWO, date.month())?;
124        wtr.write_str("-")?;
125        wtr.write_int(&FMT_TWO, date.day())?;
126        Ok(())
127    }
128
129    /// Formats the given time into the writer given.
130    pub(super) fn print_time<W: Write>(
131        &self,
132        time: &Time,
133        mut wtr: W,
134    ) -> Result<(), Error> {
135        static FMT_TWO: DecimalFormatter = DecimalFormatter::new().padding(2);
136        static FMT_FRACTION: FractionalFormatter = FractionalFormatter::new();
137
138        wtr.write_int(&FMT_TWO, time.hour())?;
139        wtr.write_str(":")?;
140        wtr.write_int(&FMT_TWO, time.minute())?;
141        wtr.write_str(":")?;
142        wtr.write_int(&FMT_TWO, time.second())?;
143        let fractional_nanosecond = time.subsec_nanosecond();
144        if self.precision.map_or(fractional_nanosecond != 0, |p| p > 0) {
145            wtr.write_str(".")?;
146            wtr.write_fraction(
147                &FMT_FRACTION.precision(self.precision),
148                fractional_nanosecond,
149            )?;
150        }
151        Ok(())
152    }
153
154    /// Formats the given time zone into the writer given.
155    pub(super) fn print_time_zone<W: Write>(
156        &self,
157        tz: &TimeZone,
158        mut wtr: W,
159    ) -> Result<(), Error> {
160        if let Some(iana_name) = tz.iana_name() {
161            return wtr.write_str(iana_name);
162        }
163        if tz.is_unknown() {
164            return wtr.write_str("Etc/Unknown");
165        }
166        if let Ok(offset) = tz.to_fixed_offset() {
167            return self.print_offset_full_precision(&offset, wtr);
168        }
169        // We get this on `alloc` because we format the POSIX time zone into a
170        // `String` first. See the note below.
171        //
172        // This is generally okay because there is no current (2025-02-28) way
173        // to create a `TimeZone` that is *only* a POSIX time zone in core-only
174        // environments. (All you can do is create a TZif time zone, which may
175        // contain a POSIX time zone, but `tz.posix_tz()` would still return
176        // `None` in that case.)
177        #[cfg(feature = "alloc")]
178        {
179            if let Some(posix_tz) = tz.posix_tz() {
180                // This is pretty unfortunate, but at time of writing, I
181                // didn't see an easy way to make the `Display` impl for
182                // `PosixTimeZone` automatically work with
183                // `jiff::fmt::Write` without allocating a new string. As
184                // far as I can see, I either have to duplicate the code or
185                // make it generic in some way. I judged neither to be worth
186                // doing for such a rare case. ---AG
187                let s = alloc::string::ToString::to_string(posix_tz);
188                return wtr.write_str(&s);
189            }
190        }
191        // Ideally this never actually happens, but it can, and there
192        // are likely system configurations out there in which it does.
193        // I can imagine "lightweight" installations that just have a
194        // `/etc/localtime` as a TZif file that doesn't point to any IANA time
195        // zone. In which case, serializing a time zone probably doesn't make
196        // much sense.
197        //
198        // Anyway, if you're seeing this error and think there should be a
199        // different behavior, please file an issue.
200        Err(err!(
201            "time zones without IANA identifiers that aren't either \
202             fixed offsets or a POSIX time zone can't be serialized \
203             (this typically occurs when this is a system time zone \
204              derived from `/etc/localtime` on Unix systems that \
205              isn't symlinked to an entry in `/usr/share/zoneinfo`)",
206        ))
207    }
208
209    pub(super) fn print_pieces<W: Write>(
210        &self,
211        pieces: &Pieces,
212        mut wtr: W,
213    ) -> Result<(), Error> {
214        if let Some(time) = pieces.time() {
215            let dt = DateTime::from_parts(pieces.date(), time);
216            self.print_datetime(&dt, &mut wtr)?;
217            if let Some(poffset) = pieces.offset() {
218                self.print_pieces_offset(&poffset, &mut wtr)?;
219            }
220        } else if let Some(poffset) = pieces.offset() {
221            // In this case, we have an offset but no time component. Since
222            // `2025-01-02-05:00` isn't valid, we forcefully write out the
223            // default time (which is what would be assumed anyway).
224            let dt = DateTime::from_parts(pieces.date(), Time::midnight());
225            self.print_datetime(&dt, &mut wtr)?;
226            self.print_pieces_offset(&poffset, &mut wtr)?;
227        } else {
228            // We have no time and no offset, so we can just write the date.
229            // It's okay to write this followed by an annotation, e.g.,
230            // `2025-01-02[America/New_York]` or even `2025-01-02[-05:00]`.
231            self.print_date(&pieces.date(), &mut wtr)?;
232        }
233        // For the time zone annotation, a `Pieces` gives us the annotation
234        // name or offset directly, where as with `Zoned`, we have a
235        // `TimeZone`. So we hand-roll our own formatter directly from the
236        // annotation.
237        if let Some(ann) = pieces.time_zone_annotation() {
238            // Note that we explicitly ignore `self.rfc9557` here, since with
239            // `Pieces`, the annotation has been explicitly provided. Also,
240            // at time of writing, `self.rfc9557` is always enabled anyway.
241            wtr.write_str("[")?;
242            if ann.is_critical() {
243                wtr.write_str("!")?;
244            }
245            match *ann.kind() {
246                TimeZoneAnnotationKind::Named(ref name) => {
247                    wtr.write_str(name.as_str())?
248                }
249                TimeZoneAnnotationKind::Offset(offset) => {
250                    self.print_offset_rounded(&offset, &mut wtr)?
251                }
252            }
253            wtr.write_str("]")?;
254        }
255        Ok(())
256    }
257
258    /// Formats the given "pieces" offset into the writer given.
259    fn print_pieces_offset<W: Write>(
260        &self,
261        poffset: &PiecesOffset,
262        mut wtr: W,
263    ) -> Result<(), Error> {
264        match *poffset {
265            PiecesOffset::Zulu => self.print_zulu(wtr),
266            PiecesOffset::Numeric(ref noffset) => {
267                if noffset.offset().is_zero() && noffset.is_negative() {
268                    wtr.write_str("-00:00")
269                } else {
270                    self.print_offset_rounded(&noffset.offset(), wtr)
271                }
272            }
273        }
274    }
275
276    /// Formats the given offset into the writer given.
277    ///
278    /// If the given offset has non-zero seconds, then they are rounded to
279    /// the nearest minute.
280    fn print_offset_rounded<W: Write>(
281        &self,
282        offset: &Offset,
283        mut wtr: W,
284    ) -> Result<(), Error> {
285        static FMT_TWO: DecimalFormatter = DecimalFormatter::new().padding(2);
286
287        wtr.write_str(if offset.is_negative() { "-" } else { "+" })?;
288        let mut hours = offset.part_hours_ranged().abs().get();
289        let mut minutes = offset.part_minutes_ranged().abs().get();
290        // RFC 3339 requires that time zone offsets are an integral number
291        // of minutes. While rounding based on seconds doesn't seem clearly
292        // indicated, the `1937-01-01T12:00:27.87+00:20` example seems
293        // to suggest that the number of minutes should be "as close as
294        // possible" to the actual offset. So we just do basic rounding
295        // here.
296        if offset.part_seconds_ranged().abs() >= C(30) {
297            if minutes == 59 {
298                hours = hours.saturating_add(1);
299                minutes = 0;
300            } else {
301                minutes = minutes.saturating_add(1);
302            }
303        }
304        wtr.write_int(&FMT_TWO, hours)?;
305        wtr.write_str(":")?;
306        wtr.write_int(&FMT_TWO, minutes)?;
307        Ok(())
308    }
309
310    /// Formats the given offset into the writer given.
311    ///
312    /// If the given offset has non-zero seconds, then they are emitted as a
313    /// third `:`-delimited component of the offset. If seconds are zero, then
314    /// only the hours and minute components are emitted.
315    fn print_offset_full_precision<W: Write>(
316        &self,
317        offset: &Offset,
318        mut wtr: W,
319    ) -> Result<(), Error> {
320        static FMT_TWO: DecimalFormatter = DecimalFormatter::new().padding(2);
321
322        wtr.write_str(if offset.is_negative() { "-" } else { "+" })?;
323        let hours = offset.part_hours_ranged().abs().get();
324        let minutes = offset.part_minutes_ranged().abs().get();
325        let seconds = offset.part_seconds_ranged().abs().get();
326        wtr.write_int(&FMT_TWO, hours)?;
327        wtr.write_str(":")?;
328        wtr.write_int(&FMT_TWO, minutes)?;
329        if seconds > 0 {
330            wtr.write_str(":")?;
331            wtr.write_int(&FMT_TWO, seconds)?;
332        }
333        Ok(())
334    }
335
336    /// Prints the "zulu" indicator.
337    ///
338    /// This should only be used when the offset is not known. For example,
339    /// when printing a `Timestamp`.
340    fn print_zulu<W: Write>(&self, mut wtr: W) -> Result<(), Error> {
341        wtr.write_str(if self.lowercase { "z" } else { "Z" })
342    }
343
344    /// Formats the given time zone name into the writer given as an RFC 9557
345    /// time zone annotation.
346    ///
347    /// This is a no-op when RFC 9557 support isn't enabled. And when the given
348    /// time zone is not an IANA time zone name, then the offset is printed
349    /// instead. (This means the offset will be printed twice, which is indeed
350    /// an intended behavior of RFC 9557 for cases where a time zone name is
351    /// not used or unavailable.)
352    fn print_time_zone_annotation<W: Write>(
353        &self,
354        time_zone: &TimeZone,
355        offset: &Offset,
356        mut wtr: W,
357    ) -> Result<(), Error> {
358        if !self.rfc9557 {
359            return Ok(());
360        }
361        wtr.write_str("[")?;
362        if let Some(iana_name) = time_zone.iana_name() {
363            wtr.write_str(iana_name)?;
364        } else {
365            self.print_offset_rounded(offset, &mut wtr)?;
366        }
367        wtr.write_str("]")?;
368        Ok(())
369    }
370}
371
372impl Default for DateTimePrinter {
373    fn default() -> DateTimePrinter {
374        DateTimePrinter::new()
375    }
376}
377
378/// A printer for Temporal spans.
379///
380/// Note that in Temporal, a "span" is called a "duration."
381#[derive(Debug)]
382pub(super) struct SpanPrinter {
383    /// Whether to use lowercase unit designators.
384    lowercase: bool,
385}
386
387impl SpanPrinter {
388    /// Create a new Temporal span printer with the default configuration.
389    pub(super) const fn new() -> SpanPrinter {
390        SpanPrinter { lowercase: false }
391    }
392
393    /// Use lowercase for unit designator labels.
394    ///
395    /// By default, unit designator labels are written in uppercase.
396    pub(super) const fn lowercase(self, yes: bool) -> SpanPrinter {
397        SpanPrinter { lowercase: yes }
398    }
399
400    /// Print the given span to the writer given.
401    ///
402    /// This only returns an error when the given writer returns an error.
403    pub(super) fn print_span<W: Write>(
404        &self,
405        span: &Span,
406        mut wtr: W,
407    ) -> Result<(), Error> {
408        static FMT_INT: DecimalFormatter = DecimalFormatter::new();
409        static FMT_FRACTION: FractionalFormatter = FractionalFormatter::new();
410
411        if span.is_negative() {
412            wtr.write_str("-")?;
413        }
414        wtr.write_str("P")?;
415
416        let mut non_zero_greater_than_second = false;
417        if span.get_years_ranged() != C(0) {
418            wtr.write_int(&FMT_INT, span.get_years_ranged().get().abs())?;
419            wtr.write_char(self.label('Y'))?;
420            non_zero_greater_than_second = true;
421        }
422        if span.get_months_ranged() != C(0) {
423            wtr.write_int(&FMT_INT, span.get_months_ranged().get().abs())?;
424            wtr.write_char(self.label('M'))?;
425            non_zero_greater_than_second = true;
426        }
427        if span.get_weeks_ranged() != C(0) {
428            wtr.write_int(&FMT_INT, span.get_weeks_ranged().get().abs())?;
429            wtr.write_char(self.label('W'))?;
430            non_zero_greater_than_second = true;
431        }
432        if span.get_days_ranged() != C(0) {
433            wtr.write_int(&FMT_INT, span.get_days_ranged().get().abs())?;
434            wtr.write_char(self.label('D'))?;
435            non_zero_greater_than_second = true;
436        }
437
438        let mut printed_time_prefix = false;
439        if span.get_hours_ranged() != C(0) {
440            if !printed_time_prefix {
441                wtr.write_str("T")?;
442                printed_time_prefix = true;
443            }
444            wtr.write_int(&FMT_INT, span.get_hours_ranged().get().abs())?;
445            wtr.write_char(self.label('H'))?;
446            non_zero_greater_than_second = true;
447        }
448        if span.get_minutes_ranged() != C(0) {
449            if !printed_time_prefix {
450                wtr.write_str("T")?;
451                printed_time_prefix = true;
452            }
453            wtr.write_int(&FMT_INT, span.get_minutes_ranged().get().abs())?;
454            wtr.write_char(self.label('M'))?;
455            non_zero_greater_than_second = true;
456        }
457
458        // ISO 8601 (and Temporal) don't support writing out milliseconds,
459        // microseconds or nanoseconds as separate components like for all
460        // the other units. Instead, they must be incorporated as fractional
461        // seconds. But we only want to do that work if we need to.
462        let (seconds, millis, micros, nanos) = (
463            span.get_seconds_ranged().abs(),
464            span.get_milliseconds_ranged().abs(),
465            span.get_microseconds_ranged().abs(),
466            span.get_nanoseconds_ranged().abs(),
467        );
468        if (seconds != C(0) || !non_zero_greater_than_second)
469            && millis == C(0)
470            && micros == C(0)
471            && nanos == C(0)
472        {
473            if !printed_time_prefix {
474                wtr.write_str("T")?;
475            }
476            wtr.write_int(&FMT_INT, seconds.get())?;
477            wtr.write_char(self.label('S'))?;
478        } else if millis != C(0) || micros != C(0) || nanos != C(0) {
479            if !printed_time_prefix {
480                wtr.write_str("T")?;
481            }
482            // We want to combine our seconds, milliseconds, microseconds and
483            // nanoseconds into one single value in terms of nanoseconds. Then
484            // we can "balance" that out so that we have a number of seconds
485            // and a number of nanoseconds not greater than 1 second. (Which is
486            // our fraction.)
487            let combined_as_nanos =
488                t::SpanSecondsOrLowerNanoseconds::rfrom(nanos)
489                    + (t::SpanSecondsOrLowerNanoseconds::rfrom(micros)
490                        * t::NANOS_PER_MICRO)
491                    + (t::SpanSecondsOrLowerNanoseconds::rfrom(millis)
492                        * t::NANOS_PER_MILLI)
493                    + (t::SpanSecondsOrLowerNanoseconds::rfrom(seconds)
494                        * t::NANOS_PER_SECOND);
495            let fraction_second = t::SpanSecondsOrLower::rfrom(
496                combined_as_nanos / t::NANOS_PER_SECOND,
497            );
498            let fraction_nano = t::SubsecNanosecond::rfrom(
499                combined_as_nanos % t::NANOS_PER_SECOND,
500            );
501            wtr.write_int(&FMT_INT, fraction_second.get())?;
502            if fraction_nano != C(0) {
503                wtr.write_str(".")?;
504                wtr.write_fraction(&FMT_FRACTION, fraction_nano.get())?;
505            }
506            wtr.write_char(self.label('S'))?;
507        }
508        Ok(())
509    }
510
511    /// Print the given signed duration to the writer given.
512    ///
513    /// This only returns an error when the given writer returns an error.
514    pub(super) fn print_duration<W: Write>(
515        &self,
516        dur: &SignedDuration,
517        mut wtr: W,
518    ) -> Result<(), Error> {
519        static FMT_INT: DecimalFormatter = DecimalFormatter::new();
520        static FMT_FRACTION: FractionalFormatter = FractionalFormatter::new();
521
522        let mut non_zero_greater_than_second = false;
523        if dur.is_negative() {
524            wtr.write_str("-")?;
525        }
526        wtr.write_str("PT")?;
527
528        let mut secs = dur.as_secs();
529        // OK because subsec_nanos -999_999_999<=nanos<=999_999_999.
530        let nanos = dur.subsec_nanos().abs();
531        // OK because guaranteed to be bigger than i64::MIN.
532        let hours = (secs / (60 * 60)).abs();
533        secs %= 60 * 60;
534        // OK because guaranteed to be bigger than i64::MIN.
535        let minutes = (secs / 60).abs();
536        // OK because guaranteed to be bigger than i64::MIN.
537        secs = (secs % 60).abs();
538        if hours != 0 {
539            wtr.write_int(&FMT_INT, hours)?;
540            wtr.write_char(self.label('H'))?;
541            non_zero_greater_than_second = true;
542        }
543        if minutes != 0 {
544            wtr.write_int(&FMT_INT, minutes)?;
545            wtr.write_char(self.label('M'))?;
546            non_zero_greater_than_second = true;
547        }
548        if (secs != 0 || !non_zero_greater_than_second) && nanos == 0 {
549            wtr.write_int(&FMT_INT, secs)?;
550            wtr.write_char(self.label('S'))?;
551        } else if nanos != 0 {
552            wtr.write_int(&FMT_INT, secs)?;
553            wtr.write_str(".")?;
554            wtr.write_fraction(&FMT_FRACTION, nanos)?;
555            wtr.write_char(self.label('S'))?;
556        }
557        Ok(())
558    }
559
560    /// Converts the uppercase unit designator label to lowercase if this
561    /// printer is configured to use lowercase. Otherwise the label is returned
562    /// unchanged.
563    fn label(&self, upper: char) -> char {
564        debug_assert!(upper.is_ascii());
565        if self.lowercase {
566            upper.to_ascii_lowercase()
567        } else {
568            upper
569        }
570    }
571}
572
573#[cfg(feature = "alloc")]
574#[cfg(test)]
575mod tests {
576    use alloc::string::String;
577
578    use crate::{civil::date, span::ToSpan};
579
580    use super::*;
581
582    #[test]
583    fn print_zoned() {
584        if crate::tz::db().is_definitively_empty() {
585            return;
586        }
587
588        let dt = date(2024, 3, 10).at(5, 34, 45, 0);
589        let zoned: Zoned = dt.in_tz("America/New_York").unwrap();
590        let mut buf = String::new();
591        DateTimePrinter::new().print_zoned(&zoned, &mut buf).unwrap();
592        assert_eq!(buf, "2024-03-10T05:34:45-04:00[America/New_York]");
593
594        let dt = date(2024, 3, 10).at(5, 34, 45, 0);
595        let zoned: Zoned = dt.in_tz("America/New_York").unwrap();
596        let zoned = zoned.with_time_zone(TimeZone::UTC);
597        let mut buf = String::new();
598        DateTimePrinter::new().print_zoned(&zoned, &mut buf).unwrap();
599        assert_eq!(buf, "2024-03-10T09:34:45+00:00[UTC]");
600    }
601
602    #[test]
603    fn print_timestamp() {
604        if crate::tz::db().is_definitively_empty() {
605            return;
606        }
607
608        let dt = date(2024, 3, 10).at(5, 34, 45, 0);
609        let zoned: Zoned = dt.in_tz("America/New_York").unwrap();
610        let mut buf = String::new();
611        DateTimePrinter::new()
612            .print_timestamp(&zoned.timestamp(), None, &mut buf)
613            .unwrap();
614        assert_eq!(buf, "2024-03-10T09:34:45Z");
615
616        let dt = date(-2024, 3, 10).at(5, 34, 45, 0);
617        let zoned: Zoned = dt.in_tz("America/New_York").unwrap();
618        let mut buf = String::new();
619        DateTimePrinter::new()
620            .print_timestamp(&zoned.timestamp(), None, &mut buf)
621            .unwrap();
622        assert_eq!(buf, "-002024-03-10T10:30:47Z");
623    }
624
625    #[test]
626    fn print_span_basic() {
627        let p = |span: Span| -> String {
628            let mut buf = String::new();
629            SpanPrinter::new().print_span(&span, &mut buf).unwrap();
630            buf
631        };
632
633        insta::assert_snapshot!(p(Span::new()), @"PT0S");
634        insta::assert_snapshot!(p(1.second()), @"PT1S");
635        insta::assert_snapshot!(p(-1.second()), @"-PT1S");
636        insta::assert_snapshot!(p(
637            1.second().milliseconds(1).microseconds(1).nanoseconds(1),
638        ), @"PT1.001001001S");
639        insta::assert_snapshot!(p(
640            0.second().milliseconds(999).microseconds(999).nanoseconds(999),
641        ), @"PT0.999999999S");
642        insta::assert_snapshot!(p(
643            1.year().months(1).weeks(1).days(1)
644            .hours(1).minutes(1).seconds(1)
645            .milliseconds(1).microseconds(1).nanoseconds(1),
646        ), @"P1Y1M1W1DT1H1M1.001001001S");
647        insta::assert_snapshot!(p(
648            -1.year().months(1).weeks(1).days(1)
649            .hours(1).minutes(1).seconds(1)
650            .milliseconds(1).microseconds(1).nanoseconds(1),
651        ), @"-P1Y1M1W1DT1H1M1.001001001S");
652    }
653
654    #[test]
655    fn print_span_subsecond_positive() {
656        let p = |span: Span| -> String {
657            let mut buf = String::new();
658            SpanPrinter::new().print_span(&span, &mut buf).unwrap();
659            buf
660        };
661
662        // These are all sub-second trickery tests.
663        insta::assert_snapshot!(p(
664            0.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
665        ), @"PT1.001001S");
666        insta::assert_snapshot!(p(
667            1.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
668        ), @"PT2.001001S");
669        insta::assert_snapshot!(p(
670            0.second()
671            .milliseconds(t::SpanMilliseconds::MAX_REPR),
672        ), @"PT631107417600S");
673        insta::assert_snapshot!(p(
674            0.second()
675            .microseconds(t::SpanMicroseconds::MAX_REPR),
676        ), @"PT631107417600S");
677        insta::assert_snapshot!(p(
678            0.second()
679            .nanoseconds(t::SpanNanoseconds::MAX_REPR),
680        ), @"PT9223372036.854775807S");
681
682        insta::assert_snapshot!(p(
683            0.second()
684            .milliseconds(t::SpanMilliseconds::MAX_REPR)
685            .microseconds(999_999),
686        ), @"PT631107417600.999999S");
687        // This is 1 microsecond more than the maximum number of seconds
688        // representable in a span.
689        insta::assert_snapshot!(p(
690            0.second()
691            .milliseconds(t::SpanMilliseconds::MAX_REPR)
692            .microseconds(1_000_000),
693        ), @"PT631107417601S");
694        insta::assert_snapshot!(p(
695            0.second()
696            .milliseconds(t::SpanMilliseconds::MAX_REPR)
697            .microseconds(1_000_001),
698        ), @"PT631107417601.000001S");
699        // This is 1 nanosecond more than the maximum number of seconds
700        // representable in a span.
701        insta::assert_snapshot!(p(
702            0.second()
703            .milliseconds(t::SpanMilliseconds::MAX_REPR)
704            .nanoseconds(1_000_000_000),
705        ), @"PT631107417601S");
706        insta::assert_snapshot!(p(
707            0.second()
708            .milliseconds(t::SpanMilliseconds::MAX_REPR)
709            .nanoseconds(1_000_000_001),
710        ), @"PT631107417601.000000001S");
711
712        // The max millis, micros and nanos, combined.
713        insta::assert_snapshot!(p(
714            0.second()
715            .milliseconds(t::SpanMilliseconds::MAX_REPR)
716            .microseconds(t::SpanMicroseconds::MAX_REPR)
717            .nanoseconds(t::SpanNanoseconds::MAX_REPR),
718        ), @"PT1271438207236.854775807S");
719        // The max seconds, millis, micros and nanos, combined.
720        insta::assert_snapshot!(p(
721            Span::new()
722            .seconds(t::SpanSeconds::MAX_REPR)
723            .milliseconds(t::SpanMilliseconds::MAX_REPR)
724            .microseconds(t::SpanMicroseconds::MAX_REPR)
725            .nanoseconds(t::SpanNanoseconds::MAX_REPR),
726        ), @"PT1902545624836.854775807S");
727    }
728
729    #[test]
730    fn print_span_subsecond_negative() {
731        let p = |span: Span| -> String {
732            let mut buf = String::new();
733            SpanPrinter::new().print_span(&span, &mut buf).unwrap();
734            buf
735        };
736
737        // These are all sub-second trickery tests.
738        insta::assert_snapshot!(p(
739            -0.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
740        ), @"-PT1.001001S");
741        insta::assert_snapshot!(p(
742            -1.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
743        ), @"-PT2.001001S");
744        insta::assert_snapshot!(p(
745            0.second()
746            .milliseconds(t::SpanMilliseconds::MIN_REPR),
747        ), @"-PT631107417600S");
748        insta::assert_snapshot!(p(
749            0.second()
750            .microseconds(t::SpanMicroseconds::MIN_REPR),
751        ), @"-PT631107417600S");
752        insta::assert_snapshot!(p(
753            0.second()
754            .nanoseconds(t::SpanNanoseconds::MIN_REPR),
755        ), @"-PT9223372036.854775807S");
756
757        insta::assert_snapshot!(p(
758            0.second()
759            .milliseconds(t::SpanMilliseconds::MIN_REPR)
760            .microseconds(999_999),
761        ), @"-PT631107417600.999999S");
762        // This is 1 microsecond more than the maximum number of seconds
763        // representable in a span.
764        insta::assert_snapshot!(p(
765            0.second()
766            .milliseconds(t::SpanMilliseconds::MIN_REPR)
767            .microseconds(1_000_000),
768        ), @"-PT631107417601S");
769        insta::assert_snapshot!(p(
770            0.second()
771            .milliseconds(t::SpanMilliseconds::MIN_REPR)
772            .microseconds(1_000_001),
773        ), @"-PT631107417601.000001S");
774        // This is 1 nanosecond more than the maximum number of seconds
775        // representable in a span.
776        insta::assert_snapshot!(p(
777            0.second()
778            .milliseconds(t::SpanMilliseconds::MIN_REPR)
779            .nanoseconds(1_000_000_000),
780        ), @"-PT631107417601S");
781        insta::assert_snapshot!(p(
782            0.second()
783            .milliseconds(t::SpanMilliseconds::MIN_REPR)
784            .nanoseconds(1_000_000_001),
785        ), @"-PT631107417601.000000001S");
786
787        // The max millis, micros and nanos, combined.
788        insta::assert_snapshot!(p(
789            0.second()
790            .milliseconds(t::SpanMilliseconds::MIN_REPR)
791            .microseconds(t::SpanMicroseconds::MIN_REPR)
792            .nanoseconds(t::SpanNanoseconds::MIN_REPR),
793        ), @"-PT1271438207236.854775807S");
794        // The max seconds, millis, micros and nanos, combined.
795        insta::assert_snapshot!(p(
796            Span::new()
797            .seconds(t::SpanSeconds::MIN_REPR)
798            .milliseconds(t::SpanMilliseconds::MIN_REPR)
799            .microseconds(t::SpanMicroseconds::MIN_REPR)
800            .nanoseconds(t::SpanNanoseconds::MIN_REPR),
801        ), @"-PT1902545624836.854775807S");
802    }
803
804    #[test]
805    fn print_duration() {
806        let p = |secs, nanos| -> String {
807            let dur = SignedDuration::new(secs, nanos);
808            let mut buf = String::new();
809            SpanPrinter::new().print_duration(&dur, &mut buf).unwrap();
810            buf
811        };
812
813        insta::assert_snapshot!(p(0, 0), @"PT0S");
814        insta::assert_snapshot!(p(0, 1), @"PT0.000000001S");
815        insta::assert_snapshot!(p(1, 0), @"PT1S");
816        insta::assert_snapshot!(p(59, 0), @"PT59S");
817        insta::assert_snapshot!(p(60, 0), @"PT1M");
818        insta::assert_snapshot!(p(60, 1), @"PT1M0.000000001S");
819        insta::assert_snapshot!(p(61, 1), @"PT1M1.000000001S");
820        insta::assert_snapshot!(p(3_600, 0), @"PT1H");
821        insta::assert_snapshot!(p(3_600, 1), @"PT1H0.000000001S");
822        insta::assert_snapshot!(p(3_660, 0), @"PT1H1M");
823        insta::assert_snapshot!(p(3_660, 1), @"PT1H1M0.000000001S");
824        insta::assert_snapshot!(p(3_661, 0), @"PT1H1M1S");
825        insta::assert_snapshot!(p(3_661, 1), @"PT1H1M1.000000001S");
826
827        insta::assert_snapshot!(p(0, -1), @"-PT0.000000001S");
828        insta::assert_snapshot!(p(-1, 0), @"-PT1S");
829        insta::assert_snapshot!(p(-59, 0), @"-PT59S");
830        insta::assert_snapshot!(p(-60, 0), @"-PT1M");
831        insta::assert_snapshot!(p(-60, -1), @"-PT1M0.000000001S");
832        insta::assert_snapshot!(p(-61, -1), @"-PT1M1.000000001S");
833        insta::assert_snapshot!(p(-3_600, 0), @"-PT1H");
834        insta::assert_snapshot!(p(-3_600, -1), @"-PT1H0.000000001S");
835        insta::assert_snapshot!(p(-3_660, 0), @"-PT1H1M");
836        insta::assert_snapshot!(p(-3_660, -1), @"-PT1H1M0.000000001S");
837        insta::assert_snapshot!(p(-3_661, 0), @"-PT1H1M1S");
838        insta::assert_snapshot!(p(-3_661, -1), @"-PT1H1M1.000000001S");
839
840        insta::assert_snapshot!(
841            p(i64::MIN, -999_999_999),
842            @"-PT2562047788015215H30M8.999999999S",
843        );
844        insta::assert_snapshot!(
845            p(i64::MAX, 999_999_999),
846            @"PT2562047788015215H30M7.999999999S",
847        );
848    }
849}
jiff/fmt/temporal/printer.rs

jiff/fmt/temporal/
printer.rs
