Feature request: DateTime intervals with mixed formats

jmoldrich2b commented 2 years ago

Hi Kip,

Thanks again for this amazing library. It's been so useful to me.

I've been using the DateTime Intervals and I'm wishing there was a way to have :medium formatted dates and :short formatted times. For e.g.,

Apr 22, 2022, 2:00:00 AM – 3:00:00 AM -> Apr 22, 2022, 2:00 AM – 3:00 AM

... or ideally this ...

Apr 22, 2022, 2:00:00 AM – 3:00:00 AM -> Apr 22, 2022, 2 AM – 3 AM

I feel like remove the redundant parts of the time makes it more legible, but a shorter date is less legible and less friendly, and doesn't generalise if I don't have the exact locale (e.g., 'en-GB' vs 'en-US'). So ideally I want:

Cldr.DateTime.Interval.to_string(start, finish, locale: locale, date_format: :medium, time_format: :short)

Looking at cldr_dates_times/blob/master/lib/cldr/interval/date_time.ex it appears that formats could be percolated down to the output functions, but the format for DateTimes are coarse at the moment, and the 'common date time formats' don't feature formats with both date and time. So I'm thinking the DateTime to_string method could be changed to handle mixed formats.

In the meantime I've hacked together something that works for me. It might be useful for someone else, so here it is:

  def localise_time_range(from, to, zone, locale) do
    from = DateTime.shift_zone!(from, zone)
    to = DateTime.shift_zone!(to, zone)
    {:ok, %{medium: format_dt}} = BackEnd.Cldr.DateTime.Format.date_time_formats("en")
    template = Cldr.Substitution.parse(format_dt)
    {:ok, %{medium: format_d}} = BackEnd.Cldr.DateTime.Format.date_formats("en")
    {:ok, %{short: format_t}} = BackEnd.Cldr.DateTime.Format.time_formats("en")
    format_dt = Cldr.Substitution.substitute([format_t, format_d], template)
      |> IO.iodata_to_binary()
    to_format = if Date.compare(from, to) == :eq, do: format_t, else: format_dt
    {:ok, from} = BackEnd.Cldr.DateTime.to_string(from, locale: "en", format: format_dt)
    {:ok, to} = BackEnd.Cldr.DateTime.to_string(to, locale: "en", format: to_format)
    interval_format = BackEnd.Cldr.DateTime.Format.date_time_interval_fallback("en")
    Cldr.Substitution.substitute([from, to], interval_format)
      |> IO.iodata_to_binary()
  end

Perhaps there's already a better way to do this with what's already there? Maybe it doesn't make sense to have this kind of complexity within the library? But I'd be curious to know what you think.

Cheers,

Jarrod

kipcole9 commented 2 years ago

@jmoldrich2b thanks for the suggestion! There are parts of the CLDR specification and data that are not yet exposed in the ex_cldr libs, typically because matching the spec to an implementation isn't always obvious. But I understand the ask and it makes sense to me. In part because as you say, for date/times the formatting is the date part and then the time part.

I won't be able to investigate very fully until the weekend but I'll get back to you after then if there is any path forward that can make this happen without breaking everything else.

Thanks again, much appreciated.

jarrodmoldrich commented 2 years ago

Thank you for the prompt reply! As I have a working solution there's no urgency from my end, but looking forward to seeing what you come up with (and using it).

p.s., I was accidentally logged in to a different account when I posted

kipcole9 commented 2 years ago

@jarrodmoldrich sorry for taking a long time to get to this. After review I don't see a practical way to do what you're after using format code (like :medium). I think the simplest way forward might be to use your own format string. Using your example:

iex> MyApp.Cldr.DateTime.Interval.to_string ~U[2022-04-22 02:00:00Z], ~U[2022-04-22 03:00:00Z], 
...> format: "MMM d, y, hh:mm a - hh:mm a"
{:ok, "Apr 22, 2022, 02:00 AM - 03:00 AM"}

To make deciding which format string to use I have published ex_cldr_dates_times version 2.12.0 that exposes the public function Cldr.DateTime.Interval.greatest_difference/2 that will return the format code of the greatest difference. That will allow differentiating amongst interval formats without having to dive deep into formatting yourself.

iex> Cldr.DateTime.Interval.greatest_difference ~U[2022-04-22 02:00:00Z], ~U[2022-04-22 03:00:00Z]                  
{:ok, :H}

Hopefully that give you an easier way forward? Let me know if that sparks any better ideas? You've been a long way down the rabbit hole of the code!

jarrodmoldrich commented 2 years ago

Thanks for looking into this!

I think the simplest way forward might be to use your own format string.

I think that's basically what I'm doing in my code snippet, except I'm building the format strings from the patterns provided by your library. This approach could be generalised to find a 'mixed format' date time:

fun date_time_format(dt_format, d_format, t_format) do
    # get formats
    {:ok, dt_formats} = BackEnd.Cldr.DateTime.Format.date_time_formats("en")
    {:ok, d_formats} = BackEnd.Cldr.DateTime.Format.date_formats("en")
    {:ok, t_formats} = BackEnd.Cldr.DateTime.Format.time_formats("en")
    # select formats
    dt_format = Map.fetch!(dt_formats, dt_format)
    d_format = Map.fetch!(d_formats, d_format)
    t_format = Map.fetch!(t_formats, t_format)
    # combine formats
    template = Cldr.Substitution.parse(dt_format)
    Cldr.Substitution.substitute([t_format, d_format], template)
      |> IO.iodata_to_binary()
end

So for the from and to in the interval it could either use the result of date_time_format(..) or simply use the appropriate time format for the to depending on the result of greatest_difference(..)

Passing the format triplet down might be polluting Interval module with unnecessary complexity, but even having just this utility function to create blended date time formats could be a useful.