Consolidate shift_time_unit/3 for add/2 and shift/2 (#13472)

Author: tfiedlerdejanze

lib/elixir/lib/calendar/date.ex

@@ -708,12 +708,7 @@ defmodule Date do
   @spec add(Calendar.date(), integer()) :: t
   def add(%{calendar: Calendar.ISO} = date, days) do
     %{year: year, month: month, day: day} = date
-
-    {year, month, day} =
-      Calendar.ISO.date_to_iso_days(year, month, day)
-      |> Kernel.+(days)
-      |> Calendar.ISO.date_from_iso_days()
-
+    {year, month, day} = Calendar.ISO.shift_days({year, month, day}, days)
     %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
   end
 

lib/elixir/lib/calendar/datetime.ex

@@ -1640,30 +1640,28 @@ defmodule DateTime do
     add(datetime, amount_to_add * 60, :second, time_zone_database)
   end
 
-  def add(datetime, amount_to_add, unit, time_zone_database) when is_integer(amount_to_add) do
+  def add(%{calendar: calendar} = datetime, amount_to_add, unit, time_zone_database)
+      when is_integer(amount_to_add) do
     %{
+      microsecond: {_, precision},
+      time_zone: time_zone,
       utc_offset: utc_offset,
-      std_offset: std_offset,
-      calendar: calendar,
-      microsecond: {_, precision}
+      std_offset: std_offset
     } = datetime
 
-    if not is_integer(unit) and
-         unit not in ~w(second millisecond microsecond nanosecond)a do
+    if not is_integer(unit) and unit not in ~w(second millisecond microsecond nanosecond)a do
       raise ArgumentError,
             "unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
     end
 
-    ppd = System.convert_time_unit(86400, :second, unit)
-    total_offset = System.convert_time_unit(utc_offset + std_offset, :second, unit)
     precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
 
     result =
       datetime
       |> to_iso_days()
-      # Subtract total offset in order to get UTC and add the integer for the addition
-      |> Calendar.ISO.add_day_fraction_to_iso_days(amount_to_add - total_offset, ppd)
-      |> shift_zone_for_iso_days_utc(calendar, precision, datetime.time_zone, time_zone_database)
+      |> Calendar.ISO.shift_time_unit(amount_to_add, unit)
+      |> apply_tz_offset(utc_offset + std_offset)
+      |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)
 
     case result do
       {:ok, result_datetime} ->

lib/elixir/lib/calendar/iso.ex

@@ -1550,7 +1550,8 @@ defmodule Calendar.ISO do
     end)
   end
 
-  defp shift_days({year, month, day}, days) do
+  @doc false
+  def shift_days({year, month, day}, days) do
     {year, month, day} =
       date_to_iso_days(year, month, day)
       |> Kernel.+(days)
@@ -1576,34 +1577,37 @@ defmodule Calendar.ISO do
     {new_year, new_month, new_day}
   end
 
-  defp shift_time_unit({year, month, day, hour, minute, second, microsecond}, value, unit)
-       when unit in [:second, :microsecond] do
+  @doc false
+  def shift_time_unit({year, month, day, hour, minute, second, microsecond}, value, unit)
+      when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do
     {value, precision} = shift_time_unit_values(value, microsecond)
 
-    ppd = System.convert_time_unit(86400, :second, unit)
-
     {year, month, day, hour, minute, second, {ms_value, _}} =
       naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
-      |> add_day_fraction_to_iso_days(value, ppd)
+      |> shift_time_unit(value, unit)
       |> naive_datetime_from_iso_days()
 
     {year, month, day, hour, minute, second, {ms_value, precision}}
   end
 
-  defp shift_time_unit({hour, minute, second, microsecond}, value, unit)
-       when unit in [:second, :microsecond] do
+  def shift_time_unit({hour, minute, second, microsecond}, value, unit)
+      when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do
     {value, precision} = shift_time_unit_values(value, microsecond)
 
-    time = {0, time_to_day_fraction(hour, minute, second, microsecond)}
-    amount_to_add = System.convert_time_unit(value, unit, :microsecond)
-    total = iso_days_to_unit(time, :microsecond) + amount_to_add
-    parts = Integer.mod(total, @parts_per_day)
+    {_days, day_fraction} =
+      shift_time_unit({0, time_to_day_fraction(hour, minute, second, microsecond)}, value, unit)
 
-    {hour, minute, second, {microsecond, _}} = time_from_day_fraction({parts, @parts_per_day})
+    {hour, minute, second, {microsecond, _}} = time_from_day_fraction(day_fraction)
 
     {hour, minute, second, {microsecond, precision}}
   end
 
+  def shift_time_unit({_days, _day_fraction} = iso_days, value, unit)
+      when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do
+    ppd = System.convert_time_unit(86400, :second, unit)
+    add_day_fraction_to_iso_days(iso_days, value, ppd)
+  end
+
   defp shift_time_unit_values({0, _}, {_, original_precision}) do
     {0, original_precision}
   end

lib/elixir/lib/calendar/naive_datetime.ex

@@ -468,23 +468,21 @@ defmodule NaiveDateTime do
   end
 
   def add(
-        %{microsecond: {_, precision}, calendar: calendar} = naive_datetime,
+        %{calendar: calendar, microsecond: {_, precision}} = naive_datetime,
         amount_to_add,
         unit
       )
       when is_integer(amount_to_add) do
-    if not is_integer(unit) and
-         unit not in ~w(second millisecond microsecond nanosecond)a do
+    if not is_integer(unit) and unit not in ~w(second millisecond microsecond nanosecond)a do
       raise ArgumentError,
             "unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
     end
 
-    ppd = System.convert_time_unit(86400, :second, unit)
     precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
 
     naive_datetime
     |> to_iso_days()
-    |> Calendar.ISO.add_day_fraction_to_iso_days(amount_to_add, ppd)
+    |> Calendar.ISO.shift_time_unit(amount_to_add, unit)
     |> from_iso_days(calendar, precision)
   end
 

lib/elixir/lib/calendar/time.ex

@@ -50,7 +50,6 @@ defmodule Time do
           calendar: Calendar.calendar()
         }
 
-  @parts_per_day 86_400_000_000
   @seconds_per_day 24 * 60 * 60
 
   @doc """
@@ -524,17 +523,19 @@ defmodule Time do
 
     unless valid? do
       raise ArgumentError,
-            "unsupported time unit. Expected :hour, :minute, :second, :millisecond, " <>
-              ":microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
+            "unsupported time unit. Expected :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
     end
 
-    amount_to_add = System.convert_time_unit(amount_to_add, unit, :microsecond)
-    total = time_to_microseconds(time) + amount_to_add
-    parts = Integer.mod(total, @parts_per_day)
+    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
+
     precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
 
-    {hour, minute, second, {microsecond, _}} =
-      calendar.time_from_day_fraction({parts, @parts_per_day})
+    {hour, minute, second, {microsecond, _precision}} =
+      Calendar.ISO.shift_time_unit(
+        {hour, minute, second, microsecond},
+        amount_to_add,
+        unit
+      )
 
     %Time{
       hour: hour,
@@ -545,21 +546,6 @@ defmodule Time do
     }
   end
 
-  defp time_to_microseconds(%{
-         calendar: Calendar.ISO,
-         hour: 0,
-         minute: 0,
-         second: 0,
-         microsecond: {0, _}
-       }) do
-    0
-  end
-
-  defp time_to_microseconds(time) do
-    iso_days = {0, to_day_fraction(time)}
-    Calendar.ISO.iso_days_to_unit(iso_days, :microsecond)
-  end
-
   @doc """
   Shifts given `time` by `duration` according to its calendar.