gix-date: make time a private dependency of gix-date

This should make the swap from `time` to `jiff` easier.

This comment[1] indicates that it's okay for `time` to be a public
dependency, but since this patch series is about swapping `time` for
`jiff`, it seemed appropriate to take this step first. And in
particular, it was *almost* already the case that `time` was a private
dependency of `gix-date`. The only thing we really had to button up was
the exposure of `time`'s custom formatting description language.

Jiff doesn't support `time`'s custom formatting machinery and instead
uses a strftime/strptime like API. We could expose that instead, but
since nothing (other than a test) was actually utilizing `time`'s custom
formatting machinery external to `gix-date`, I figured we might as well
completely encapsulate it.

[1]: #471 (comment)

Author: BurntSushi

gix-date/src/parse.rs

@@ -32,18 +32,18 @@ pub(crate) mod function {
             return Ok(Time::new(42, 1800));
         }
 
-        Ok(if let Ok(val) = Date::parse(input, SHORT) {
+        Ok(if let Ok(val) = Date::parse(input, SHORT.0) {
             let val = val.with_hms(0, 0, 0).expect("date is in range").assume_utc();
             Time::new(val.unix_timestamp(), val.offset().whole_seconds())
         } else if let Ok(val) = OffsetDateTime::parse(input, &well_known::Rfc2822) {
             Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601) {
+        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601.0) {
             Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT) {
+        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT.0) {
             Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, GITOXIDE) {
+        } else if let Ok(val) = OffsetDateTime::parse(input, GITOXIDE.0) {
             Time::new(val.unix_timestamp(), val.offset().whole_seconds())
-        } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
+        } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT.0) {
             Time::new(val.unix_timestamp(), val.offset().whole_seconds())
         } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
             // Format::Unix

gix-date/src/time/format.rs

@@ -1,81 +1,74 @@
-use time::{format_description::FormatItem, macros::format_description};
+use time::macros::format_description;
 
-use crate::{time::Format, Time};
+use crate::{
+    time::{CustomFormat, Format},
+    Time,
+};
 
 /// E.g. `2018-12-24`
-pub const SHORT: &[FormatItem<'_>] = format_description!("[year]-[month]-[day]");
+pub const SHORT: CustomFormat = CustomFormat(format_description!("[year]-[month]-[day]"));
 
 /// E.g. `Thu, 18 Aug 2022 12:45:06 +0800`
-pub const RFC2822: &[FormatItem<'_>] = format_description!(
+pub const RFC2822: CustomFormat = CustomFormat(format_description!(
     "[weekday repr:short], [day] [month repr:short] [year] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]"
-);
+));
 
 /// E.g. `Thu, 8 Aug 2022 12:45:06 +0800`. This is output by `git log --pretty=%aD`.
-pub const GIT_RFC2822: &[FormatItem<'_>] = format_description!(
+pub const GIT_RFC2822: CustomFormat = CustomFormat(format_description!(
     "[weekday repr:short], \
      [day padding:none] \
      [month repr:short] \
      [year] \
      [hour]:[minute]:[second] \
      [offset_hour sign:mandatory][offset_minute]"
-);
+));
 
 /// E.g. `2022-08-17 22:04:58 +0200`
-pub const ISO8601: &[FormatItem<'_>] =
-    format_description!("[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]");
+pub const ISO8601: CustomFormat = CustomFormat(format_description!(
+    "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]"
+));
 
 /// E.g. `2022-08-17T21:43:13+08:00`
-pub const ISO8601_STRICT: &[FormatItem<'_>] =
-    format_description!("[year]-[month]-[day]T[hour]:[minute]:[second][offset_hour sign:mandatory]:[offset_minute]");
+pub const ISO8601_STRICT: CustomFormat = CustomFormat(format_description!(
+    "[year]-[month]-[day]T[hour]:[minute]:[second][offset_hour sign:mandatory]:[offset_minute]"
+));
 
 /// E.g. `123456789`
-pub const UNIX: Format<'static> = Format::Unix;
+pub const UNIX: Format = Format::Unix;
 
 /// E.g. `1660874655 +0800`
-pub const RAW: Format<'static> = Format::Raw;
+pub const RAW: Format = Format::Raw;
 
 /// E.g. `Thu Sep 04 2022 10:45:06 -0400`, like the git `DEFAULT`, but with the year and time fields swapped.
-pub const GITOXIDE: &[FormatItem<'_>] = format_description!(
+pub const GITOXIDE: CustomFormat = CustomFormat(format_description!(
     "[weekday repr:short] [month repr:short] [day] [year] [hour]:[minute]:[second] [offset_hour sign:mandatory][offset_minute]"
-);
+));
 
 /// E.g. `Thu Sep 4 10:45:06 2022 -0400`. This is output by `git log --pretty=%ad`.
-pub const DEFAULT: &[FormatItem<'_>] = format_description!(
+pub const DEFAULT: CustomFormat = CustomFormat(format_description!(
     "[weekday repr:short] \
      [month repr:short] \
      [day padding:none] \
      [hour]:[minute]:[second] \
      [year] \
      [offset_hour sign:mandatory][offset_minute]"
-);
-
-mod format_impls {
-    use time::format_description::FormatItem;
-
-    use crate::time::Format;
-
-    impl<'a> From<&'a [FormatItem<'a>]> for Format<'a> {
-        fn from(f: &'a [FormatItem<'a>]) -> Self {
-            Format::Custom(f)
-        }
-    }
-}
+));
 
 /// Formatting
 impl Time {
     /// Format this instance according to the given `format`.
     ///
-    /// Use the [`format_description`](https://time-rs.github.io/book/api/format-description.html) macro to create and
-    /// validate formats at compile time, courtesy of the [`time`] crate.
-    pub fn format<'a>(&self, format: impl Into<Format<'a>>) -> String {
+    /// Use [`Format::Unix`], [`Format::Raw`] or one of the custom formats
+    /// defined in the [`format`](mod@crate::time::format) submodule.
+    pub fn format(&self, format: impl Into<Format>) -> String {
         self.format_inner(format.into())
     }
 
-    fn format_inner(&self, format: Format<'_>) -> String {
+    fn format_inner(&self, format: Format) -> String {
         match format {
-            Format::Custom(format) => self
+            Format::Custom(CustomFormat(format)) => self
                 .to_time()
-                .format(&format)
+                .format(format)
                 .expect("well-known format into memory never fails"),
             Format::Unix => self.seconds.to_string(),
             Format::Raw => self.to_bstring().to_string(),

gix-date/src/time/mod.rs

@@ -19,15 +19,26 @@ pub enum Sign {
 
 /// Various ways to describe a time format.
 #[derive(Debug, Clone, Copy)]
-pub enum Format<'a> {
-    /// A custom format typically defined with the [`format_description`][time::format_description] macro.
-    Custom(&'a [time::format_description::FormatItem<'a>]),
+pub enum Format {
+    /// A custom format limited to what's in the
+    /// [`format`](mod@crate::time::format) submodule.
+    Custom(CustomFormat),
     /// The seconds since 1970, also known as unix epoch, like `1660874655`.
     Unix,
     /// The seconds since 1970, followed by the offset, like `1660874655 +0800`
     Raw,
 }
 
+/// A custom format for printing and parsing time.
+#[derive(Clone, Copy, Debug)]
+pub struct CustomFormat(pub(crate) &'static [time::format_description::FormatItem<'static>]);
+
+impl From<CustomFormat> for Format {
+    fn from(custom_format: CustomFormat) -> Format {
+        Format::Custom(custom_format)
+    }
+}
+
 ///
 #[allow(clippy::empty_docs)]
 pub mod format;

gix-date/tests/time/format.rs

@@ -2,7 +2,6 @@ use gix_date::{
     time::{format, Format, Sign},
     Time,
 };
-use time::macros::format_description;
 
 #[test]
 fn short() {
@@ -72,14 +71,6 @@ fn git_default() {
     )
 }
 
-#[test]
-fn custom_compile_time() {
-    assert_eq!(
-        time().format(format_description!("[year]-[month]-[day] [hour]:[minute]:[second]")),
-        "1973-11-30 00:03:09",
-    );
-}
-
 fn time() -> Time {
     Time {
         seconds: 123456789,