zf

zenflows testing
git clone https://s.sonu.ch/~srfsh/zf.git
Log | Files | Refs | Submodules | README | LICENSE

prepare_checks_to_run.ex (3048B)

      1 defmodule Credo.CLI.Task.PrepareChecksToRun do
      2   @moduledoc false
      3 
      4   use Credo.Execution.Task
      5 
      6   def call(exec, _opts \\ []) do
      7     source_files = Execution.get_source_files(exec)
      8 
      9     exec
     10     |> set_config_comments(source_files)
     11     |> enable_disabled_checks_if_applicable()
     12     |> exclude_low_priority_checks(exec.min_priority - 9)
     13     |> exclude_checks_based_on_elixir_version
     14   end
     15 
     16   defp set_config_comments(exec, source_files) do
     17     config_comment_map =
     18       source_files
     19       |> Credo.Check.ConfigCommentFinder.run()
     20       |> Enum.into(%{})
     21 
     22     %Execution{exec | config_comment_map: config_comment_map}
     23   end
     24 
     25   defp enable_disabled_checks_if_applicable(%Execution{enable_disabled_checks: nil} = exec) do
     26     exec
     27   end
     28 
     29   defp enable_disabled_checks_if_applicable(exec) do
     30     enable_disabled_checks_regexes = to_match_regexes(exec.enable_disabled_checks)
     31 
     32     enable_disabled_checks =
     33       Enum.map(exec.checks.disabled, fn
     34         {check, params} ->
     35           if matches?(to_string(check), enable_disabled_checks_regexes) do
     36             {check, params}
     37           else
     38             {check, false}
     39           end
     40       end)
     41 
     42     checks = Keyword.merge(exec.checks.enabled, enable_disabled_checks)
     43 
     44     %Execution{exec | checks: %{enabled: checks, disabled: exec.checks.disabled}}
     45   end
     46 
     47   defp exclude_low_priority_checks(exec, below_priority) do
     48     checks =
     49       Enum.reject(exec.checks.enabled, fn
     50         # deprecated
     51         {check} ->
     52           Credo.Priority.to_integer(check.base_priority) < below_priority
     53 
     54         {_check, false} ->
     55           true
     56 
     57         {check, params} ->
     58           priority =
     59             params
     60             |> Credo.Check.Params.priority(check)
     61             |> Credo.Priority.to_integer()
     62 
     63           priority < below_priority
     64       end)
     65 
     66     %Execution{exec | checks: %{enabled: checks, disabled: exec.checks.disabled}}
     67   end
     68 
     69   defp exclude_checks_based_on_elixir_version(exec) do
     70     elixir_version = System.version()
     71     skipped_checks = Enum.reject(exec.checks.enabled, &matches_requirement?(&1, elixir_version))
     72     checks = Enum.filter(exec.checks.enabled, &matches_requirement?(&1, elixir_version))
     73 
     74     %Execution{
     75       exec
     76       | checks: %{enabled: checks, disabled: exec.checks.disabled},
     77         skipped_checks: skipped_checks
     78     }
     79   end
     80 
     81   defp matches_requirement?({check, _}, elixir_version) do
     82     matches_requirement?({check}, elixir_version)
     83   end
     84 
     85   defp matches_requirement?({check}, elixir_version) do
     86     Version.match?(elixir_version, check.elixir_version)
     87   end
     88 
     89   defp to_match_regexes(nil), do: []
     90 
     91   defp to_match_regexes(list) do
     92     Enum.map(list, fn match_check ->
     93       {:ok, match_pattern} = Regex.compile(match_check, "i")
     94       match_pattern
     95     end)
     96   end
     97 
     98   defp matches?(_string, nil), do: false
     99   defp matches?(string, list) when is_list(list), do: Enum.any?(list, &matches?(string, &1))
    100   defp matches?(string, %Regex{} = regex), do: Regex.match?(regex, string)
    101   defp matches?(string, pattern) when is_binary(pattern), do: String.contains?(string, pattern)
    102 end