defmodule Credo.ConfigFile do
@moduledoc """
`ConfigFile` structs represent all loaded and merged config files in a run.
"""
@config_filename ".credo.exs"
@default_config_name "default"
@origin_user :file
@default_glob "**/*.{ex,exs}"
@default_files_included [@default_glob]
@default_files_excluded []
@default_parse_timeout 5000
@default_strict false
@default_color true
@valid_checks_keys ~w(enabled disabled extra)a
alias Credo.Execution
defstruct origin: nil,
filename: nil,
config_name_found?: nil,
files: nil,
color: true,
checks: nil,
requires: [],
plugins: [],
parse_timeout: nil,
strict: false
@doc """
Returns Execution struct representing a consolidated Execution for all `.credo.exs`
files in `relevant_directories/1` merged into the default configuration.
- `config_name`: name of the configuration to load
- `safe`: if +true+, the config files are loaded using static analysis rather
than `Code.eval_string/1`
"""
def read_or_default(exec, dir, config_name \\ nil, safe \\ false) do
dir
|> relevant_config_files
|> combine_configs(exec, dir, config_name, safe)
end
@doc """
Returns the provided config_file merged into the default configuration.
- `config_file`: full path to the custom configuration file
- `config_name`: name of the configuration to load
- `safe`: if +true+, the config files are loaded using static analysis rather
than `Code.eval_string/1`
"""
def read_from_file_path(exec, dir, config_filename, config_name \\ nil, safe \\ false) do
if File.exists?(config_filename) do
combine_configs([config_filename], exec, dir, config_name, safe)
else
{:error, {:notfound, "Given config file does not exist: #{config_filename}"}}
end
end
defp combine_configs(files, exec, dir, config_name, safe) do
config_files =
files
|> Enum.filter(&File.exists?/1)
|> Enum.map(&{@origin_user, &1, File.read!(&1)})
exec = Enum.reduce(config_files, exec, &Execution.append_config_file(&2, &1))
Execution.get_config_files(exec)
|> Enum.map(&from_exs(exec, dir, config_name || @default_config_name, &1, safe))
|> ensure_any_config_found(config_name)
|> merge()
|> map_ok_files()
|> ensure_values_present()
end
defp ensure_any_config_found(list, config_name) do
config_not_found =
Enum.all?(list, fn
{:ok, %__MODULE__{config_name_found?: false}} -> true
_ -> false
end)
if config_not_found do
filenames_as_list =
list
|> Enum.map(fn
{:ok, %__MODULE__{origin: :file, filename: filename}} -> " * #{filename}\n"
_ -> nil
end)
|> Enum.reject(&is_nil/1)
message =
case filenames_as_list do
[] ->
"Given config name #{inspect(config_name)} does not exist."
filenames_as_list ->
"""
Given config name #{inspect(config_name)} does not exist in any config file:
#{filenames_as_list}
"""
end
|> String.trim()
{:error, {:config_name_not_found, message}}
else
list
end
end
defp relevant_config_files(dir) do
dir
|> relevant_directories
|> add_config_files
end
@doc """
Returns all parent directories of the given `dir` as well as each `./config`
sub-directory.
"""
def relevant_directories(dir) do
dir
|> Path.expand()
|> Path.split()
|> Enum.reverse()
|> get_dir_paths
|> add_config_dirs
end
defp ensure_values_present({:ok, config}) do
# TODO: config.check_for_updates is deprecated, but should not lead to a validation error
config = %__MODULE__{
origin: config.origin,
filename: config.filename,
config_name_found?: config.config_name_found?,
checks: config.checks,
color: merge_boolean(@default_color, config.color),
files: %{
included: merge_files_default(@default_files_included, config.files.included),
excluded: merge_files_default(@default_files_excluded, config.files.excluded)
},
parse_timeout: merge_parse_timeout(@default_parse_timeout, config.parse_timeout),
plugins: config.plugins || [],
requires: config.requires || [],
strict: merge_boolean(@default_strict, config.strict)
}
{:ok, config}
end
defp ensure_values_present(error), do: error
defp get_dir_paths(dirs), do: do_get_dir_paths(dirs, [])
defp do_get_dir_paths(dirs, acc) when length(dirs) < 2, do: acc
defp do_get_dir_paths([dir | tail], acc) do
expanded_path =
tail
|> Enum.reverse()
|> Path.join()
|> Path.join(dir)
do_get_dir_paths(tail, [expanded_path | acc])
end
defp add_config_dirs(paths) do
Enum.flat_map(paths, fn path -> [path, Path.join(path, "config")] end)
end
defp add_config_files(paths) do
for path <- paths, do: Path.join(path, @config_filename)
end
defp from_exs(exec, dir, config_name, {origin, filename, exs_string}, safe) do
case Credo.ExsLoader.parse(exs_string, filename, exec, safe) do
{:ok, data} ->
from_data(data, dir, filename, origin, config_name)
{:error, {line_no, description, trigger}} ->
{:error, {:badconfig, filename, line_no, description, trigger}}
{:error, reason} ->
{:error, {:badconfig, filename, reason}}
end
end
defp from_data(data, dir, filename, origin, config_name) do
data =
data[:configs]
|> List.wrap()
|> Enum.find(&(&1[:name] == config_name))
config_name_found? = not is_nil(data)
config_file = %__MODULE__{
origin: origin,
filename: filename,
config_name_found?: config_name_found?,
checks: checks_from_data(data, filename),
color: data[:color],
files: files_from_data(data, dir),
parse_timeout: data[:parse_timeout],
plugins: data[:plugins] || [],
requires: data[:requires] || [],
strict: data[:strict]
}
{:ok, config_file}
end
defp files_from_data(data, dir) do
case data[:files] do
nil ->
nil
%{} = files ->
included_files = files[:included] || dir
included_dir =
included_files
|> List.wrap()
|> Enum.map(&join_default_files_if_directory/1)
%{
included: included_dir,
excluded: files[:excluded] || @default_files_excluded
}
end
end
defp checks_from_data(data, filename) do
case data[:checks] do
checks when is_list(checks) ->
checks
%{} = checks ->
do_warn_if_check_params_invalid(checks, filename)
checks
_ ->
[]
end
end
defp do_warn_if_check_params_invalid(checks, filename) do
Enum.each(checks, fn
{checks_key, _name} when checks_key not in @valid_checks_keys ->
candidate = find_best_match(@valid_checks_keys, checks_key)
warning = warning_message_for(filename, checks_key, candidate)
Credo.CLI.Output.UI.warn([:red, warning])
_ ->
nil
end)
end
defp warning_message_for(filename, checks_key, candidate) do
if candidate do
"** (config) #{filename}: config field `:checks` contains unknown key `#{inspect(checks_key)}`. Did you mean `#{inspect(candidate)}`?"
else
"** (config) #{filename}: config field `:checks` contains unknown key `#{inspect(checks_key)}`."
end
end
defp find_best_match(candidates, given, threshold \\ 0.8) do
given_string = to_string(given)
{jaro_distance, candidate} =
candidates
|> Enum.map(fn candidate_name ->
distance = String.jaro_distance(given_string, to_string(candidate_name))
{distance, candidate_name}
end)
|> Enum.sort()
|> List.last()
if jaro_distance > threshold do
candidate
end
end
@doc """
Merges the given structs from left to right, meaning that later entries
overwrites earlier ones.
merge(base, other)
Any options in `other` will overwrite those in `base`.
The `files:` field is merged, meaning that you can define `included` and/or
`excluded` and only override the given one.
The `checks:` field is merged.
"""
def merge(list) when is_list(list) do
base = List.first(list)
tail = List.delete_at(list, 0)
merge(tail, base)
end
# bubble up errors from parsing the config so we can deal with them at the top-level
def merge({:error, _} = error), do: error
def merge([], config), do: config
def merge([other | tail], base) do
new_base = merge(base, other)
merge(tail, new_base)
end
# bubble up errors from parsing the config so we can deal with them at the top-level
def merge({:error, _} = a, _), do: a
def merge(_, {:error, _} = a), do: a
def merge({:ok, base}, {:ok, other}) do
config_file = %__MODULE__{
checks: merge_checks(base, other),
color: merge_boolean(base.color, other.color),
files: merge_files(base, other),
parse_timeout: merge_parse_timeout(base.parse_timeout, other.parse_timeout),
plugins: base.plugins ++ other.plugins,
requires: base.requires ++ other.requires,
strict: merge_boolean(base.strict, other.strict)
}
{:ok, config_file}
end
defp merge_boolean(base, other)
defp merge_boolean(_base, true), do: true
defp merge_boolean(_base, false), do: false
defp merge_boolean(base, _), do: base
defp merge_files_default(_base, [_head | _tail] = non_empty_list), do: non_empty_list
defp merge_files_default(base, _), do: base
defp merge_parse_timeout(_base, timeout) when is_integer(timeout), do: timeout
defp merge_parse_timeout(base, _), do: base
def merge_checks(%__MODULE__{checks: checks_list_base}, %__MODULE__{checks: checks_list_other})
when is_list(checks_list_base) and is_list(checks_list_other) do
base = %__MODULE__{checks: %{enabled: checks_list_base}}
other = %__MODULE__{checks: %{extra: checks_list_other}}
merge_checks(base, other)
end
def merge_checks(%__MODULE__{checks: checks_base}, %__MODULE__{
checks: %{extra: _} = checks_map_other
})
when is_list(checks_base) do
base = %__MODULE__{checks: %{enabled: checks_base}}
other = %__MODULE__{checks: checks_map_other}
merge_checks(base, other)
end
def merge_checks(%__MODULE__{checks: %{enabled: checks_list_base}}, %__MODULE__{
checks: checks_other
})
when is_list(checks_list_base) and is_list(checks_other) do
base = %__MODULE__{checks: %{enabled: checks_list_base}}
other = %__MODULE__{checks: %{extra: checks_other}}
merge_checks(base, other)
end
def merge_checks(%__MODULE__{checks: _checks_base}, %__MODULE__{
checks: %{enabled: checks_other_enabled} = checks_other
})
when is_list(checks_other_enabled) do
disabled = disable_check_tuples(checks_other[:disabled])
%{
enabled: checks_other_enabled |> normalize_check_tuples() |> Keyword.merge(disabled),
disabled: checks_other[:disabled] || []
}
end
def merge_checks(%__MODULE__{checks: %{enabled: checks_base}}, %__MODULE__{
checks: %{} = checks_other
})
when is_list(checks_base) do
base = normalize_check_tuples(checks_base)
other = normalize_check_tuples(checks_other[:extra])
disabled = disable_check_tuples(checks_other[:disabled])
%{
enabled: base |> Keyword.merge(other) |> Keyword.merge(disabled),
disabled: checks_other[:disabled] || []
}
end
# this def catches all the cases where no valid key was found in `checks_map_other`
def merge_checks(%__MODULE__{checks: %{enabled: checks_base}}, %__MODULE__{
checks: %{}
})
when is_list(checks_base) do
base = %__MODULE__{checks: %{enabled: checks_base}}
other = %__MODULE__{checks: []}
merge_checks(base, other)
end
#
def merge_files(%__MODULE__{files: files_base}, %__MODULE__{files: files_other}) do
%{
included: files_other[:included] || files_base[:included],
excluded: files_other[:excluded] || files_base[:excluded]
}
end
defp normalize_check_tuples(nil), do: []
defp normalize_check_tuples(list) when is_list(list) do
Enum.map(list, &normalize_check_tuple/1)
end
defp normalize_check_tuple({name}), do: {name, []}
defp normalize_check_tuple(tuple), do: tuple
defp disable_check_tuples(nil), do: []
defp disable_check_tuples(list) when is_list(list) do
Enum.map(list, &disable_check_tuple/1)
end
defp disable_check_tuple({name}), do: {name, false}
defp disable_check_tuple({name, _params}), do: {name, false}
defp join_default_files_if_directory(dir) do
if File.dir?(dir) do
Path.join(dir, @default_files_included)
else
dir
end
end
defp map_ok_files({:error, _} = error) do
error
end
defp map_ok_files({:ok, %__MODULE__{files: files} = config}) do
files = %{
included:
files[:included]
|> List.wrap()
|> Enum.uniq(),
excluded:
files[:excluded]
|> List.wrap()
|> Enum.uniq()
}
{:ok, %__MODULE__{config | files: files}}
end
end
