fix: Parametrize iana database download_url

Author: rai200890

.formatter.exs

@@ -1,4 +1,5 @@
 # Used by "mix format"
 [
-  inputs: ["lib/tzdata/period_builder.ex", "test/tz_period_builder_test.exs"]
+  import_deps: [:hackney],
+  inputs: ["*.{heex,ex,exs}", "{config,lib,test}/**/*.{heex,ex,exs}"]
 ]

.gitignore

@@ -4,3 +4,4 @@ erl_crash.dump
 *.ez
 /doc
 /priv/latest_remote_poll.txt
+/priv/tmp_downloads

VERSION

@@ -0,0 +1 @@
+1.2.0

config/config.exs

@@ -1,7 +1,9 @@
 # This file is responsible for configuring your application
 # and its dependencies with the aid of the Mix.Config module.
-use Mix.Config
+import Config
 
 config :logger, utc_log: true
 config :tzdata, :autoupdate, :enabled
+
+config :tzdata, download_url: "https://data.iana.org/time-zones/tzdata-latest.tar.gz"
 # config :tzdata, :data_dir, "/etc/elixir_tzdata_storage"

lib/tzdata.ex

@@ -31,21 +31,21 @@ defmodule Tzdata do
   zone_list provides a list of all the zone names that can be used with
   DateTime. This includes aliases.
   """
-  @spec zone_list() :: [Calendar.time_zone]
-  def zone_list, do: Tzdata.ReleaseReader.zone_and_link_list
+  @spec zone_list() :: [Calendar.time_zone()]
+  def zone_list, do: Tzdata.ReleaseReader.zone_and_link_list()
 
   @doc """
   Like zone_list, but excludes aliases for zones.
   """
-  @spec canonical_zone_list() :: [Calendar.time_zone]
-  def canonical_zone_list, do: Tzdata.ReleaseReader.zone_list
+  @spec canonical_zone_list() :: [Calendar.time_zone()]
+  def canonical_zone_list, do: Tzdata.ReleaseReader.zone_list()
 
   @doc """
   A list of aliases for zone names. For instance Europe/Jersey
   is an alias for Europe/London. Aliases are also known as linked zones.
   """
-  @spec zone_alias_list() :: [Calendar.time_zone]
-  def zone_alias_list, do: Tzdata.ReleaseReader.link_list
+  @spec zone_alias_list() :: [Calendar.time_zone()]
+  def zone_alias_list, do: Tzdata.ReleaseReader.link_list()
 
   @doc """
   Takes the name of a zone. Returns true if zone exists. Otherwise false.
@@ -57,7 +57,7 @@ defmodule Tzdata do
       iex> Tzdata.zone_exists? "Europe/Jersey"
       true
   """
-  @spec zone_exists?(String.t) :: boolean()
+  @spec zone_exists?(String.t()) :: boolean()
   def zone_exists?(name), do: Enum.member?(zone_list(), name)
 
   @doc """
@@ -69,7 +69,7 @@ defmodule Tzdata do
       iex> Tzdata.canonical_zone? "Europe/Jersey"
       false
   """
-  @spec canonical_zone?(Calendar.time_zone) :: boolean()
+  @spec canonical_zone?(Calendar.time_zone()) :: boolean()
   def canonical_zone?(name), do: Enum.member?(canonical_zone_list(), name)
 
   @doc """
@@ -81,7 +81,7 @@ defmodule Tzdata do
       iex> Tzdata.zone_alias? "Europe/London"
       false
   """
-  @spec zone_alias?(Calendar.time_zone) :: boolean()
+  @spec zone_alias?(Calendar.time_zone()) :: boolean()
   def zone_alias?(name), do: Enum.member?(zone_alias_list(), name)
 
   @doc """
@@ -90,16 +90,16 @@ defmodule Tzdata do
       iex> Tzdata.links["Europe/Jersey"]
       "Europe/London"
   """
-  @spec links() :: %{Calendar.time_zone => Calendar.time_zone}
-  def links, do: Tzdata.ReleaseReader.links
+  @spec links() :: %{Calendar.time_zone() => Calendar.time_zone()}
+  def links, do: Tzdata.ReleaseReader.links()
 
   @doc """
   Returns a map with keys being group names and the values lists of
   time zone names. The group names mirror the file names used by the tzinfo
   database.
   """
-  @spec zone_lists_grouped() :: %{atom() => [Calendar.time_zone]}
-  def zone_lists_grouped, do: Tzdata.ReleaseReader.by_group
+  @spec zone_lists_grouped() :: %{atom() => [Calendar.time_zone()]}
+  def zone_lists_grouped, do: Tzdata.ReleaseReader.by_group()
 
   @doc """
   Returns tzdata release version as a string.
@@ -109,8 +109,8 @@ defmodule Tzdata do
       Tzdata.tzdata_version
       "2014i"
   """
-  @spec tzdata_version() :: String.t
-  def tzdata_version, do: Tzdata.ReleaseReader.release_version
+  @spec tzdata_version() :: String.t()
+  def tzdata_version, do: Tzdata.ReleaseReader.release_version()
 
   @doc """
   Returns a list of periods for the `zone_name` provided as an argument.
@@ -138,12 +138,14 @@ defmodule Tzdata do
       iex> Tzdata.periods("Not existing")
       {:error, :not_found}
   """
-  @spec periods(Calendar.time_zone) :: {:ok, [time_zone_period]} | {:error, atom()}
+  @spec periods(Calendar.time_zone()) :: {:ok, [time_zone_period]} | {:error, atom()}
   def periods(zone_name) do
     {tag, p} = Tzdata.ReleaseReader.periods_for_zone_or_link(zone_name)
+
     case tag do
       :ok ->
-        mapped_p = for {_, f_utc, f_wall, f_std, u_utc, u_wall, u_std, utc_off, std_off, zone_abbr} <- p do
+        mapped_p =
+          for {_, f_utc, f_wall, f_std, u_utc, u_wall, u_std, utc_off, std_off, zone_abbr} <- p do
             %{
               std_off: std_off,
               utc_off: utc_off,
@@ -152,8 +154,11 @@ defmodule Tzdata do
               zone_abbr: zone_abbr
             }
           end
+
         {:ok, mapped_p}
-      _ -> {:error, p}
+
+      _ ->
+        {:error, p}
     end
   end
 
@@ -191,15 +196,18 @@ defmodule Tzdata do
       iex> Tzdata.periods_for_time("Europe/Copenhagen", 63594816000, :wall)
       []
   """
-  @spec periods_for_time(Calendar.time_zone, gregorian_seconds, :standard | :wall | :utc) :: [time_zone_period] | {:error, term}
+  @spec periods_for_time(Calendar.time_zone(), gregorian_seconds, :standard | :wall | :utc) ::
+          [time_zone_period] | {:error, term}
   def periods_for_time(zone_name, time_point, time_type) do
     case possible_periods_for_zone_and_time(zone_name, time_point, time_type) do
       {:ok, periods} ->
         match_fn = fn %{from: from, until: until} ->
           smaller_than_or_equals(Map.get(from, time_type), time_point) &&
             bigger_than(Map.get(until, time_type), time_point)
         end
+
         do_consecutive_matching(periods, match_fn, [], false)
+
       {:error, _} = error ->
         error
     end
@@ -210,49 +218,62 @@ defmodule Tzdata do
   # remaining list.
   defp do_consecutive_matching([], _fun, [], _did_last_match), do: []
   defp do_consecutive_matching([], _fun, matched, _did_last_match), do: matched
+
   defp do_consecutive_matching(_list, _fun, matched, false) when matched != [] do
     # If there are matches and previous did not match then the matches are no
     # long consecutive. So we return the result.
-    matched |> Enum.reverse
+    matched |> Enum.reverse()
   end
-  defp do_consecutive_matching([h|t], fun, matched, _did_last_match) do
+
+  defp do_consecutive_matching([h | t], fun, matched, _did_last_match) do
     if fun.(h) == true do
-      do_consecutive_matching(t, fun, [h|matched], true)
+      do_consecutive_matching(t, fun, [h | matched], true)
     else
       do_consecutive_matching(t, fun, matched, false)
     end
   end
 
   # Use dynamic periods for points in time that are about 40 years into the future
   @years_in_the_future_where_precompiled_periods_are_used 40
-  @point_from_which_to_use_dynamic_periods :calendar.datetime_to_gregorian_seconds {{(:calendar.universal_time|>elem(0)|>elem(0)) + @years_in_the_future_where_precompiled_periods_are_used, 1, 1}, {0, 0, 0}}
-  defp possible_periods_for_zone_and_time(zone_name, time_point, time_type) when time_point >= @point_from_which_to_use_dynamic_periods do
+  @point_from_which_to_use_dynamic_periods :calendar.datetime_to_gregorian_seconds(
+                                             {{(:calendar.universal_time() |> elem(0) |> elem(0)) +
+                                                 @years_in_the_future_where_precompiled_periods_are_used,
+                                               1, 1}, {0, 0, 0}}
+                                           )
+  defp possible_periods_for_zone_and_time(zone_name, time_point, time_type)
+       when time_point >= @point_from_which_to_use_dynamic_periods do
     if Tzdata.FarFutureDynamicPeriods.zone_in_30_years_in_eternal_period?(zone_name) do
       periods(zone_name)
     else
-      link_status = Tzdata.ReleaseReader.links |> Map.get(zone_name)
+      link_status = Tzdata.ReleaseReader.links() |> Map.get(zone_name)
+
       if link_status == nil do
         Tzdata.FarFutureDynamicPeriods.periods_for_point_in_time(time_point, zone_name)
       else
         possible_periods_for_zone_and_time(link_status, time_point, time_type)
       end
     end
   end
+
   defp possible_periods_for_zone_and_time(zone_name, time_point, time_type) do
-    {:ok, periods} = Tzdata.ReleaseReader.periods_for_zone_time_and_type(zone_name, time_point, time_type)
-    mapped_periods = periods
-    |> Enum.sort_by(fn {_, from_utc, _, _, _, _, _, _, _, _} -> -(from_utc |> Tzdata.ReleaseReader.delimiter_to_number) end)
-    |> Enum.map(
-      fn {_, f_utc, f_wall, f_std, u_utc, u_wall, u_std, utc_off, std_off, zone_abbr} ->
-            %{
-              std_off: std_off,
-              utc_off: utc_off,
-              from: %{utc: f_utc, wall: f_wall, standard: f_std},
-              until: %{utc: u_utc, standard: u_std, wall: u_wall},
-              zone_abbr: zone_abbr
-            }
-          end
-    )
+    {:ok, periods} =
+      Tzdata.ReleaseReader.periods_for_zone_time_and_type(zone_name, time_point, time_type)
+
+    mapped_periods =
+      periods
+      |> Enum.sort_by(fn {_, from_utc, _, _, _, _, _, _, _, _} ->
+        -(from_utc |> Tzdata.ReleaseReader.delimiter_to_number())
+      end)
+      |> Enum.map(fn {_, f_utc, f_wall, f_std, u_utc, u_wall, u_std, utc_off, std_off, zone_abbr} ->
+        %{
+          std_off: std_off,
+          utc_off: utc_off,
+          from: %{utc: f_utc, wall: f_wall, standard: f_std},
+          until: %{utc: u_utc, standard: u_std, wall: u_wall},
+          zone_abbr: zone_abbr
+        }
+      end)
+
     {:ok, mapped_periods}
   end
 
@@ -270,7 +291,7 @@ defmodule Tzdata do
   """
   @spec leap_seconds_with_tai_diff() :: [%{date_time: :calendar.datetime(), tai_diff: integer}]
   def leap_seconds_with_tai_diff do
-    leap_seconds_data = Tzdata.ReleaseReader.leap_sec_data
+    leap_seconds_data = Tzdata.ReleaseReader.leap_sec_data()
     leap_seconds_data.leap_seconds
   end
 
@@ -305,7 +326,7 @@ defmodule Tzdata do
   """
   @spec leap_second_data_valid_until() :: :calendar.datetime()
   def leap_second_data_valid_until do
-    leap_seconds_data = Tzdata.ReleaseReader.leap_sec_data
+    leap_seconds_data = Tzdata.ReleaseReader.leap_sec_data()
     leap_seconds_data.valid_until
   end
 

lib/tzdata/basic_data_map.ex

@@ -3,9 +3,12 @@ defmodule Tzdata.BasicDataMap do
 
   alias Tzdata.Parser
   alias Tzdata.ParserOrganizer, as: Organizer
+
   @file_names ~w(africa antarctica asia australasia backward etcetera europe northamerica southamerica)s
   def from_files_in_dir(dir_name) do
-    Enum.map(@file_names, fn file_name -> {String.to_atom(file_name), Parser.read_file(file_name, dir_name)} end)
+    Enum.map(@file_names, fn file_name ->
+      {String.to_atom(file_name), Parser.read_file(file_name, dir_name)}
+    end)
     |> make_map
   end
 
@@ -15,26 +18,30 @@ defmodule Tzdata.BasicDataMap do
   end
 
   def make_map(all_files_read) do
-    all_files_flattened = all_files_read |> Enum.map(fn {_name, read_file} -> read_file end) |> List.flatten
+    all_files_flattened =
+      all_files_read |> Enum.map(fn {_name, read_file} -> read_file end) |> List.flatten()
+
     rules = Organizer.rules(all_files_flattened)
     zones = Organizer.zones(all_files_flattened)
     links = Organizer.links(all_files_flattened)
     zone_list = Organizer.zone_list(all_files_flattened)
     link_list = Organizer.link_list(all_files_flattened)
     zone_and_link_list = Organizer.zone_and_link_list(all_files_flattened)
 
-    by_group = all_files_read
-    |> Enum.map(fn {name, file_read} -> {name, Organizer.zone_and_link_list(file_read)} end)
-    |> Enum.into(Map.new)
+    by_group =
+      all_files_read
+      |> Enum.map(fn {name, file_read} -> {name, Organizer.zone_and_link_list(file_read)} end)
+      |> Enum.into(Map.new())
+
     {:ok,
-      %{rules: rules,
-      zones: zones,
-      links: links,
-      zone_list: zone_list,
-      link_list: link_list,
-      zone_and_link_list: zone_and_link_list,
-      by_group: by_group,
-      }
-    }
+     %{
+       rules: rules,
+       zones: zones,
+       links: links,
+       zone_list: zone_list,
+       link_list: link_list,
+       zone_and_link_list: zone_and_link_list,
+       by_group: by_group
+     }}
   end
 end

lib/tzdata/data_builder.ex

@@ -16,9 +16,7 @@ defmodule Tzdata.DataBuilder do
       File.rm_rf(tzdata_dir)
 
       Logger.info(
-        "Downloaded tzdata release from IANA is the same version as the version currently in use (#{
-          current_version
-        })."
+        "Downloaded tzdata release from IANA is the same version as the version currently in use (#{current_version})."
       )
 
       {:error, :downloaded_version_same_as_current_version}
@@ -45,8 +43,8 @@ defmodule Tzdata.DataBuilder do
 
     map.zone_list
     |> Enum.each(fn zone_name ->
-         insert_periods_for_zone(table, map, zone_name)
-       end)
+      insert_periods_for_zone(table, map, zone_name)
+    end)
 
     # remove temporary tzdata dir
     File.rm_rf(tzdata_dir)
@@ -65,7 +63,7 @@ defmodule Tzdata.DataBuilder do
   defp leap_sec_data(tzdata_dir), do: LeapSecParser.read_file(tzdata_dir)
 
   def ets_file_name_for_release_version(release_version) do
-    "#{release_dir()}/#{release_version}.v#{Tzdata.EtsHolder.file_version}.ets"
+    "#{release_dir()}/#{release_version}.v#{Tzdata.EtsHolder.file_version()}.ets"
   end
 
   def ets_table_name_for_release_version(release_version) do
@@ -79,10 +77,11 @@ defmodule Tzdata.DataBuilder do
     tuple_periods =
       periods
       |> Enum.map(fn period ->
-           period_to_tuple(key, period)
-         end)
+        period_to_tuple(key, period)
+      end)
 
-    tuple_periods |> Enum.each(fn tuple_period ->
+    tuple_periods
+    |> Enum.each(fn tuple_period ->
       :ets.insert(table, tuple_period)
     end)
   end