commit 249aa7309fc1aed26096feeb3d0bf413ec1d5f00 parent e86496f1663c06874558cc40d9570c160ff1f1f1 Author: srfsh <dev@srf.sh> Date: Thu, 20 Oct 2022 20:22:59 +0300 dep update dialyxir v1.2.0 Diffstat:
16 files changed, 282 insertions(+), 153 deletions(-)
diff --git a/.deps/dialyxir/.hex b/.deps/dialyxir/.hex Binary files differ. diff --git a/.deps/dialyxir/README.md b/.deps/dialyxir/README.md @@ -49,14 +49,16 @@ mix dialyzer ### Command line options - * `--no-compile` - do not compile even if needed. - * `--no-check` - do not perform (quick) check to see if PLT needs to be updated. - * `--ignore-exit-status` - display warnings but do not halt the VM or return an exit status code - * `--format short` - format the warnings in a compact format. - * `--format raw` - format the warnings in format returned before Dialyzer formatting - * `--format dialyxir` - format the warnings in a pretty printed format - * `--format dialyzer` - format the warnings in the original Dialyzer format - * `--quiet` - suppress all informational messages + * `--no-compile` - do not compile even if needed. + * `--no-check` - do not perform (quick) check to see if PLT needs to be updated. + * `--ignore-exit-status` - display warnings but do not halt the VM or return an exit status code. + * `--format short` - format the warnings in a compact format, suitable for ignore file using Elixir term format. + * `--format raw` - format the warnings in format returned before Dialyzer formatting. + * `--format dialyxir` - format the warnings in a pretty printed format. + * `--format dialyzer` - format the warnings in the original Dialyzer format, suitable for ignore file using simple string matches. + * `--format github` - format the warnings in the Github Actions message format. + * `--format ignore_file` - format the warnings to be suitable for adding to Elixir Format ignore file. + * `--quiet` - suppress all informational messages. Warning flags passed to this task are passed on to `:dialyzer` - e.g. @@ -80,7 +82,7 @@ To use Dialyzer in CI, you must be aware of several things: 2) The PLT should be cached using the CI caching system 3) The PLT will need to be rebuilt whenever adding a new Erlang or Elixir version to build matrix -Using Travis, this would look like: +### Travis `.travis.yml` ```markdown @@ -100,6 +102,43 @@ cache: - priv/plts ``` +### Github Actions + +`dialyzer.yml` +```yaml +... + steps: + - uses: actions/checkout@v2 + - name: Set up Elixir + id: beam + uses: erlef/setup-beam@v1 + with: + elixir-version: "1.12.3" # Define the elixir version + otp-version: "24.1" # Define the OTP version + + # Don't cache PLTs based on mix.lock hash, as Dialyzer can incrementally update even old ones + # Cache key based on Elixir & Erlang version (also useful when running in matrix) + - name: Restore PLT cache + uses: actions/cache@v2 + id: plt_cache + with: + key: | + ${{ runner.os }}-${{ steps.beam.outputs.elixir-version }}-${{ steps.beam.outputs.otp-version }}-plt + restore-keys: | + ${{ runner.os }}-${{ steps.beam.outputs.elixir-version }}-${{ steps.beam.outputs.otp-version }}-plt + path: | + priv/plts + + # Create PLTs if no cache was found + - name: Create PLTs + if: steps.plt_cache.outputs.cache-hit != 'true' + run: mix dialyzer --plt + + - name: Run dialyzer + run: mix dialyzer --format github + +``` + `mix.exs` ```elixir def project do @@ -254,6 +293,8 @@ end This file comes in two formats: `--format dialyzer` string matches (compatible with `<= 0.5.1` ignore files), and the [term format](#elixir-term-format). +Dialyzer will look for an ignore file using the term format with the name `.dialyzer_ignore.exs` by default if you don't specify something otherwise. + #### Simple String Matches Any line of dialyzer format output (partially) matching a line in `"dialyzer.ignore-warnings"` is filtered. @@ -264,7 +305,7 @@ For example, in a project where `mix dialyzer --format dialyzer` outputs: ``` Proceeding with analysis... -config.ex:64: The call ets:insert('Elixir.MyApp.Config',{'Elixir.MyApp.Config',_}) might have an unintended effect due to a possible race condition caused by its combination withthe ets:lookup('Elixir.MyApp.Config','Elixir.MyApp.Config') call in config.ex on line 26 +config.ex:64: The call ets:insert('Elixir.MyApp.Config',{'Elixir.MyApp.Config',_}) might have an unintended effect due to a possible race condition caused by its combination with the ets:lookup('Elixir.MyApp.Config','Elixir.MyApp.Config') call in config.ex on line 26 config.ex:79: Guard test is_binary(_@5::#{'__exception__':='true', '__struct__':=_, _=>_}) can never succeed config.ex:79: Guard test is_atom(_@6::#{'__exception__':='true', '__struct__':=_, _=>_}) can never succeed done in 0m1.32s @@ -282,15 +323,15 @@ And then run `mix dialyzer` would output: ``` Proceeding with analysis... -config.ex:64: The call ets:insert('Elixir.MyApp.Config',{'Elixir.MyApp.Config',_}) might have an unintended effect due to a possible race condition caused by its combination withthe ets:lookup('Elixir.MyApp.Config','Elixir.MyApp.Config') call in config.ex on line 26 +config.ex:64: The call ets:insert('Elixir.MyApp.Config',{'Elixir.MyApp.Config',_}) might have an unintended effect due to a possible race condition caused by its combination with the ets:lookup('Elixir.MyApp.Config','Elixir.MyApp.Config') call in config.ex on line 26 done in 0m1.32s done (warnings were emitted) ``` #### Elixir Term Format -Dialyxir also recognizes an Elixir format of the ignore file. If your ignore file is an `exs` file, Dialyxir will evaluate it and process its data structure. The file looks like the following, and can match either tuple patterns or an arbitrary Regex -applied to the *short-description* (`mix dialyzer --format short`): +Dialyxir also recognizes an Elixir format of the ignore file. If your ignore file is an `exs` file, Dialyxir will evaluate it and process its data structure. A line may be either a tuple or an arbitrary Regex +applied to the *short-description* format of Dialyzer output (`mix dialyzer --format short`). The file looks like the following: ```elixir # .dialyzer_ignore.exs @@ -312,6 +353,9 @@ applied to the *short-description* (`mix dialyzer --format short`): ] ``` +Entries for existing warnings can be generated with `mix dialyzer --format short`. Just remember to put the output in quotes and braces to match the format above. + + #### List unused Filters As filters tend to become obsolete (either because a discrepancy was fixed, or because the location diff --git a/.deps/dialyxir/hex_metadata.config b/.deps/dialyxir/hex_metadata.config @@ -9,9 +9,15 @@ <<"lib/dialyxir">>,<<"lib/dialyxir/warnings.ex">>, <<"lib/dialyxir/warning.ex">>,<<"lib/dialyxir/warning_helpers.ex">>, <<"lib/dialyxir/formatter.ex">>,<<"lib/dialyxir/dialyzer.ex">>, - <<"lib/dialyxir/filter_map.ex">>,<<"lib/dialyxir/plt.ex">>, - <<"lib/dialyxir/output.ex">>,<<"lib/dialyxir/project.ex">>, - <<"lib/dialyxir/warnings">>,<<"lib/dialyxir/warnings/contract_diff.ex">>, + <<"lib/dialyxir/formatter">>,<<"lib/dialyxir/formatter/raw.ex">>, + <<"lib/dialyxir/formatter/github.ex">>, + <<"lib/dialyxir/formatter/dialyzer.ex">>, + <<"lib/dialyxir/formatter/short.ex">>, + <<"lib/dialyxir/formatter/ignore_file.ex">>, + <<"lib/dialyxir/formatter/dialyxir.ex">>,<<"lib/dialyxir/filter_map.ex">>, + <<"lib/dialyxir/plt.ex">>,<<"lib/dialyxir/output.ex">>, + <<"lib/dialyxir/project.ex">>,<<"lib/dialyxir/warnings">>, + <<"lib/dialyxir/warnings/contract_diff.ex">>, <<"lib/dialyxir/warnings/missing_range.ex">>, <<"lib/dialyxir/warnings/guard_fail.ex">>, <<"lib/dialyxir/warnings/negative_guard_fail.ex">>, @@ -69,4 +75,4 @@ {<<"optional">>,false}, {<<"repository">>,<<"hexpm">>}, {<<"requirement">>,<<">= 0.2.6">>}]]}. -{<<"version">>,<<"1.1.0">>}. +{<<"version">>,<<"1.2.0">>}. diff --git a/.deps/dialyxir/lib/dialyxir/dialyzer.ex b/.deps/dialyxir/lib/dialyxir/dialyzer.ex @@ -20,22 +20,28 @@ defmodule Dialyxir.Dialyzer do formatter = cond do split[:format] == "dialyzer" -> - :dialyzer + Dialyxir.Formatter.Dialyzer split[:format] == "dialyxir" -> - :dialyxir + Dialyxir.Formatter.Dialyxir + + split[:format] == "github" -> + Dialyxir.Formatter.Github + + split[:format] == "ignore_file" -> + Dialyxir.Formatter.IgnoreFile split[:format] == "raw" -> - :raw + Dialyxir.Formatter.Raw split[:format] == "short" -> - :short + Dialyxir.Formatter.Short split[:raw] -> - :raw + Dialyxir.Formatter.Raw true -> - :dialyxir + Dialyxir.Formatter.Dialyxir end info("Starting Dialyzer") diff --git a/.deps/dialyxir/lib/dialyxir/formatter.ex b/.deps/dialyxir/lib/dialyxir/formatter.ex @@ -9,13 +9,19 @@ defmodule Dialyxir.Formatter do alias Dialyxir.FilterMap + @type warning() :: {tag :: term(), {file :: Path.t(), line :: pos_integer()}, {atom(), list()}} + + @type t() :: module() + + @callback format(warning()) :: String.t() + def formatted_time(duration_us) do minutes = div(duration_us, 60_000_000) seconds = (rem(duration_us, 60_000_000) / 1_000_000) |> Float.round(2) "done in #{minutes}m#{seconds}s" end - @spec format_and_filter([tuple], module, Keyword.t(), atom) :: tuple + @spec format_and_filter([tuple], module, Keyword.t(), t()) :: tuple def format_and_filter(warnings, filterer, filter_map_args, formatter) do filter_map = filterer.filter_map(filter_map_args) @@ -24,7 +30,8 @@ defmodule Dialyxir.Formatter do formatted_warnings = filtered_warnings |> filter_legacy_warnings(filterer) - |> Enum.map(&format_warning(&1, formatter)) + |> Enum.map(&formatter.format/1) + |> Enum.uniq() show_count_skipped(warnings, formatted_warnings, filter_map) formatted_unnecessary_skips = format_unnecessary_skips(filter_map) @@ -45,110 +52,6 @@ defmodule Dialyxir.Formatter do end end - defp format_warning(warning, :raw) do - inspect(warning, limit: :infinity) - end - - defp format_warning(warning, :dialyzer) do - # OTP 22 uses indented output, but that's incompatible with dialyzer.ignore-warnings format. - # Can be disabled, but OTP 21 and older only accept an atom, so only disable on OTP 22+. - opts = - if String.to_integer(System.otp_release()) < 22, - do: :fullpath, - else: [{:filename_opt, :fullpath}, {:indent_opt, false}] - - warning - |> :dialyzer.format_warning(opts) - |> String.Chars.to_string() - |> String.replace_trailing("\n", "") - end - - defp format_warning({_tag, {file, line}, message}, :short) do - {warning_name, arguments} = message - base_name = Path.relative_to_cwd(file) - - warning = warning(warning_name) - string = warning.format_short(arguments) - - "#{base_name}:#{line}:#{warning_name} #{string}" - end - - defp format_warning(dialyzer_warning = {_tag, {file, line}, message}, :dialyxir) do - {warning_name, arguments} = message - base_name = Path.relative_to_cwd(file) - - formatted = - try do - warning = warning(warning_name) - string = warning.format_long(arguments) - - """ - #{base_name}:#{line}:#{warning_name} - #{string} - """ - rescue - e -> - message = """ - Unknown error occurred: #{inspect(e)} - """ - - wrap_error_message(message, dialyzer_warning) - catch - {:error, :unknown_warning, warning_name} -> - message = """ - Unknown warning: - #{inspect(warning_name)} - """ - - wrap_error_message(message, dialyzer_warning) - - {:error, :lexing, warning} -> - message = """ - Failed to lex warning: - #{inspect(warning)} - """ - - wrap_error_message(message, dialyzer_warning) - - {:error, :parsing, failing_string} -> - message = """ - Failed to parse warning: - #{inspect(failing_string)} - """ - - wrap_error_message(message, dialyzer_warning) - - {:error, :pretty_printing, failing_string} -> - message = """ - Failed to pretty print warning: - #{inspect(failing_string)} - """ - - wrap_error_message(message, dialyzer_warning) - - {:error, :formatting, code} -> - message = """ - Failed to format warning: - #{inspect(code)} - """ - - wrap_error_message(message, dialyzer_warning) - end - - formatted <> String.duplicate("_", 80) - end - - defp wrap_error_message(message, warning) do - """ - Please file a bug in https://github.com/jeremyjh/dialyxir/issues with this message. - - #{message} - - Legacy warning: - #{format_warning(warning, :dialyzer)} - """ - end - defp show_count_skipped(warnings, filtered_warnings, filter_map) do warnings_count = Enum.count(warnings) filtered_warnings_count = Enum.count(filtered_warnings) @@ -184,16 +87,6 @@ defmodule Dialyxir.Formatter do |> Enum.count() end - defp warning(warning_name) do - warnings = Dialyxir.Warnings.warnings() - - if Map.has_key?(warnings, warning_name) do - Map.get(warnings, warning_name) - else - throw({:error, :unknown_warning, warning_name}) - end - end - defp filter_warnings(warnings, filterer, filter_map) do {warnings, filter_map} = Enum.map_reduce(warnings, filter_map, &filter_warning(filterer, &1, &2)) @@ -207,7 +100,7 @@ defmodule Dialyxir.Formatter do {skip?, matching_filters} = try do filterer.filter_warning?( - {to_string(file), warning_type, line, format_warning(warning, :short)}, + {to_string(file), warning_type, line, Dialyxir.Formatter.Short.format(warning)}, filter_map ) rescue @@ -237,7 +130,7 @@ defmodule Dialyxir.Formatter do Enum.reject(warnings, fn warning -> formatted_warnings = warning - |> format_warning(:dialyzer) + |> Dialyxir.Formatter.Dialyzer.format() |> List.wrap() Enum.empty?(filterer.filter_legacy_warnings(formatted_warnings)) diff --git a/.deps/dialyxir/lib/dialyxir/formatter/dialyxir.ex b/.deps/dialyxir/lib/dialyxir/formatter/dialyxir.ex @@ -0,0 +1,92 @@ +defmodule Dialyxir.Formatter.Dialyxir do + @moduledoc false + + @behaviour Dialyxir.Formatter + + @impl Dialyxir.Formatter + def format(dialyzer_warning = {_tag, {file, line}, message}) do + {warning_name, arguments} = message + base_name = Path.relative_to_cwd(file) + + formatted = + try do + warning = warning(warning_name) + string = warning.format_long(arguments) + + """ + #{base_name}:#{line}:#{warning_name} + #{string} + """ + rescue + e -> + message = """ + Unknown error occurred: #{inspect(e)} + """ + + wrap_error_message(message, dialyzer_warning) + catch + {:error, :unknown_warning, warning_name} -> + message = """ + Unknown warning: + #{inspect(warning_name)} + """ + + wrap_error_message(message, dialyzer_warning) + + {:error, :lexing, warning} -> + message = """ + Failed to lex warning: + #{inspect(warning)} + """ + + wrap_error_message(message, dialyzer_warning) + + {:error, :parsing, failing_string} -> + message = """ + Failed to parse warning: + #{inspect(failing_string)} + """ + + wrap_error_message(message, dialyzer_warning) + + {:error, :pretty_printing, failing_string} -> + message = """ + Failed to pretty print warning: + #{inspect(failing_string)} + """ + + wrap_error_message(message, dialyzer_warning) + + {:error, :formatting, code} -> + message = """ + Failed to format warning: + #{inspect(code)} + """ + + wrap_error_message(message, dialyzer_warning) + end + + formatted <> String.duplicate("_", 80) + end + + defp wrap_error_message(message, warning) do + """ + Please file a bug in https://github.com/jeremyjh/dialyxir/issues with this message. + + #{message} + + Legacy warning: + #{Dialyxir.Formatter.Dialyzer.format(warning)} + """ + end + + defp warning(warning_name) do + warnings = Dialyxir.Warnings.warnings() + + if Map.has_key?(warnings, warning_name) do + Map.get(warnings, warning_name) + else + throw({:error, :unknown_warning, warning_name}) + end + end +end diff --git a/.deps/dialyxir/lib/dialyxir/formatter/dialyzer.ex b/.deps/dialyxir/lib/dialyxir/formatter/dialyzer.ex @@ -0,0 +1,20 @@ +defmodule Dialyxir.Formatter.Dialyzer do + @moduledoc false + + @behaviour Dialyxir.Formatter + + @impl Dialyxir.Formatter + def format(warning) do + # OTP 22 uses indented output, but that's incompatible with dialyzer.ignore-warnings format. + # Can be disabled, but OTP 21 and older only accept an atom, so only disable on OTP 22+. + opts = + if String.to_integer(System.otp_release()) < 22, + do: :fullpath, + else: [{:filename_opt, :fullpath}, {:indent_opt, false}] + + warning + |> :dialyzer.format_warning(opts) + |> String.Chars.to_string() + |> String.replace_trailing("\n", "") + end +end diff --git a/.deps/dialyxir/lib/dialyxir/formatter/github.ex b/.deps/dialyxir/lib/dialyxir/formatter/github.ex @@ -0,0 +1,25 @@ +defmodule Dialyxir.Formatter.Github do + @moduledoc false + + @behaviour Dialyxir.Formatter + + @impl Dialyxir.Formatter + def format({_tag, {file, line}, {warning_name, arguments}}) do + base_name = Path.relative_to_cwd(file) + + warning = warning(warning_name) + string = warning.format_short(arguments) + + "::warning file=#{base_name},line=#{line},title=#{warning_name}::#{string}" + end + + defp warning(warning_name) do + warnings = Dialyxir.Warnings.warnings() + + if Map.has_key?(warnings, warning_name) do + Map.get(warnings, warning_name) + else + throw({:error, :unknown_warning, warning_name}) + end + end +end diff --git a/.deps/dialyxir/lib/dialyxir/formatter/ignore_file.ex b/.deps/dialyxir/lib/dialyxir/formatter/ignore_file.ex @@ -0,0 +1,10 @@ +defmodule Dialyxir.Formatter.IgnoreFile do + @moduledoc false + + @behaviour Dialyxir.Formatter + + @impl Dialyxir.Formatter + def format({_tag, {file, _line}, {warning_name, _arguments}}) do + ~s({"#{file}", :#{warning_name}},) + end +end diff --git a/.deps/dialyxir/lib/dialyxir/formatter/raw.ex b/.deps/dialyxir/lib/dialyxir/formatter/raw.ex @@ -0,0 +1,10 @@ +defmodule Dialyxir.Formatter.Raw do + @moduledoc false + + @behaviour Dialyxir.Formatter + + @impl Dialyxir.Formatter + def format(warning) do + inspect(warning, limit: :infinity) + end +end diff --git a/.deps/dialyxir/lib/dialyxir/formatter/short.ex b/.deps/dialyxir/lib/dialyxir/formatter/short.ex @@ -0,0 +1,25 @@ +defmodule Dialyxir.Formatter.Short do + @moduledoc false + + @behaviour Dialyxir.Formatter + + @impl Dialyxir.Formatter + def format({_tag, {file, line}, {warning_name, arguments}}) do + base_name = Path.relative_to_cwd(file) + + warning = warning(warning_name) + string = warning.format_short(arguments) + + "#{base_name}:#{line}:#{warning_name} #{string}" + end + + defp warning(warning_name) do + warnings = Dialyxir.Warnings.warnings() + + if Map.has_key?(warnings, warning_name) do + Map.get(warnings, warning_name) + else + throw({:error, :unknown_warning, warning_name}) + end + end +end diff --git a/.deps/dialyxir/lib/dialyxir/warnings/function_application_no_function.ex b/.deps/dialyxir/lib/dialyxir/warnings/function_application_no_function.ex @@ -30,9 +30,7 @@ defmodule Dialyxir.Warnings.FunctionApplicationNoFunction do pretty_op = Erlex.pretty_print(op) pretty_type = Erlex.pretty_print_type(type) - "Function application will fail, because #{pretty_op} :: #{pretty_type} is not a function of arity #{ - arity - }." + "Function application will fail, because #{pretty_op} :: #{pretty_type} is not a function of arity #{arity}." end @impl Dialyxir.Warning diff --git a/.deps/dialyxir/lib/dialyxir/warnings/opaque_match.ex b/.deps/dialyxir/lib/dialyxir/warnings/opaque_match.ex @@ -36,9 +36,7 @@ defmodule Dialyxir.Warnings.OpaqueMatch do def format_short([_pattern, type | _]) do pretty_type = Erlex.pretty_print_type(type) - "Attempted to pattern match against the internal structure of an opaque term of type #{ - pretty_type - }." + "Attempted to pattern match against the internal structure of an opaque term of type #{pretty_type}." end @impl Dialyxir.Warning diff --git a/.deps/dialyxir/lib/mix/tasks/dialyzer.ex b/.deps/dialyxir/lib/mix/tasks/dialyzer.ex @@ -17,10 +17,12 @@ defmodule Mix.Tasks.Dialyzer do * `--list-unused-filters` - list unused ignore filters useful for CI. do not use with `mix do`. * `--plt` - only build the required PLT(s) and exit - * `--format short` - format the warnings in a compact format - * `--format raw` - format the warnings in format returned before Dialyzer formatting - * `--format dialyxir` - format the warnings in a pretty printed format - * `--format dialyzer` - format the warnings in the original Dialyzer format + * `--format short` - format the warnings in a compact format + * `--format raw` - format the warnings in format returned before Dialyzer formatting + * `--format dialyxir` - format the warnings in a pretty printed format + * `--format dialyzer` - format the warnings in the original Dialyzer format + * `--format github` - format the warnings in the Github Actions message format + * `--format ignore_file` - format the warnings to be suitable for adding to Elixir Format ignore file * `--quiet` - suppress all informational messages Warning flags passed to this task are passed on to `:dialyzer` - e.g. diff --git a/.deps/dialyxir/mix.exs b/.deps/dialyxir/mix.exs @@ -2,7 +2,7 @@ defmodule Dialyxir.Mixfile do use Mix.Project @source_url "https://github.com/jeremyjh/dialyxir" - @version "1.1.0" + @version "1.2.0" def project do [ diff --git a/mix.lock b/mix.lock @@ -10,7 +10,7 @@ "credo": {:hex, :credo, "1.6.7", "323f5734350fd23a456f2688b9430e7d517afb313fbd38671b8a4449798a7854", [:mix], [{:bunt, "~> 0.2.1", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2.8", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "41e110bfb007f7eda7f897c10bf019ceab9a0b269ce79f015d54b0dcf4fc7dd3"}, "db_connection": {:hex, :db_connection, "2.4.2", "f92e79aff2375299a16bcb069a14ee8615c3414863a6fef93156aee8e86c2ff3", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "4fe53ca91b99f55ea249693a0229356a08f4d1a7931d8ffa79289b145fe83668"}, "decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"}, - "dialyxir": {:hex, :dialyxir, "1.1.0", "c5aab0d6e71e5522e77beff7ba9e08f8e02bad90dfbeffae60eaf0cb47e29488", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "07ea8e49c45f15264ebe6d5b93799d4dd56a44036cf42d0ad9c960bc266c0b9a"}, + "dialyxir": {:hex, :dialyxir, "1.2.0", "58344b3e87c2e7095304c81a9ae65cb68b613e28340690dfe1a5597fd08dec37", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "61072136427a851674cab81762be4dbeae7679f85b1272b6d25c3a839aff8463"}, "earmark_parser": {:hex, :earmark_parser, "1.4.25", "2024618731c55ebfcc5439d756852ec4e85978a39d0d58593763924d9a15916f", [:mix], [], "hexpm", "56749c5e1c59447f7b7a23ddb235e4b3defe276afc220a6227237f3efe83f51e"}, "ecto": {:hex, :ecto, "3.9.1", "67173b1687afeb68ce805ee7420b4261649d5e2deed8fe5550df23bab0bc4396", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c80bb3d736648df790f7f92f81b36c922d9dd3203ca65be4ff01d067f54eb304"}, "ecto_sql": {:hex, :ecto_sql, "3.9.0", "2bb21210a2a13317e098a420a8c1cc58b0c3421ab8e3acfa96417dab7817918c", [:mix], [{:db_connection, "~> 2.5 or ~> 2.4.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.9.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a8f3f720073b8b1ac4c978be25fa7960ed7fd44997420c304a4a2e200b596453"},