zf

abc_size.ex (7741B)

---

 defmodule Credo.Check.Refactor.ABCSize do
   use Credo.Check,
     tags: [:controversial],
     param_defaults: [
       max_size: 30,
       excluded_functions: []
     ],
     explanations: [
       check: """
       The ABC size describes a metric based on assignments, branches and conditions.
 
       A high ABC size is a hint that a function might be doing "more" than it
       should.
 
       As always: Take any metric with a grain of salt. Since this one was originally
       introduced for C, C++ and Java, we still have to see whether or not this can
       be a useful metric in a declarative language like Elixir.
       """,
       params: [
         max_size: "The maximum ABC size a function should have.",
         excluded_functions: "All functions listed will be ignored."
       ]
     ]
 
   @ecto_functions ["where", "from", "select", "join"]
   @def_ops [:def, :defp, :defmacro]
   @branch_ops [:.]
   @condition_ops [:if, :unless, :for, :try, :case, :cond, :and, :or, :&&, :||]
   @non_calls [:==, :fn, :__aliases__, :__block__, :if, :or, :|>, :%{}]
 
   @doc false
   @impl true
   def run(%SourceFile{} = source_file, params) do
     ignore_ecto? = imports_ecto_query?(source_file)
     issue_meta = IssueMeta.for(source_file, params)
     max_abc_size = Params.get(params, :max_size, __MODULE__)
     excluded_functions = Params.get(params, :excluded_functions, __MODULE__)
 
     excluded_functions =
       if ignore_ecto? do
         @ecto_functions ++ excluded_functions
       else
         excluded_functions
       end
 
     Credo.Code.prewalk(
       source_file,
       &traverse(&1, &2, issue_meta, max_abc_size, excluded_functions)
     )
   end
 
   defp imports_ecto_query?(source_file),
     do: Credo.Code.prewalk(source_file, &traverse_for_ecto/2, false)
 
   defp traverse_for_ecto(_, true), do: {nil, true}
 
   defp traverse_for_ecto({:import, _, [{:__aliases__, _, [:Ecto, :Query]} | _]}, false),
     do: {nil, true}
 
   defp traverse_for_ecto(ast, false), do: {ast, false}
 
   defp traverse(
          {:defmacro, _, [{:__using__, _, _}, _]} = ast,
          issues,
          _issue_meta,
          _max_abc_size,
          _excluded_functions
        ) do
     {ast, issues}
   end
 
   # TODO: consider for experimental check front-loader (ast)
   # NOTE: see above how we want to exclude certain front-loads
   for op <- @def_ops do
     defp traverse(
            {unquote(op), meta, arguments} = ast,
            issues,
            issue_meta,
            max_abc_size,
            excluded_functions
          )
          when is_list(arguments) do
       abc_size =
         ast
         |> abc_size_for(excluded_functions)
         |> round
 
       if abc_size > max_abc_size do
         fun_name = Credo.Code.Module.def_name(ast)
 
         {ast,
          [
            issue_for(issue_meta, meta[:line], fun_name, max_abc_size, abc_size)
            | issues
          ]}
       else
         {ast, issues}
       end
     end
   end
 
   defp traverse(ast, issues, _issue_meta, _max_abc_size, _excluded_functions) do
     {ast, issues}
   end
 
   @doc """
   Returns the ABC size for the block inside the given AST, which is expected
   to represent a function or macro definition.
 
       iex> {:def, [line: 1],
       ...>   [
       ...>     {:first_fun, [line: 1], nil},
       ...>     [do: {:=, [line: 2], [{:x, [line: 2], nil}, 1]}]
       ...>   ]
       ...> } |> Credo.Check.Refactor.ABCSize.abc_size
       1.0
   """
   def abc_size_for({_def_op, _meta, arguments}, excluded_functions) when is_list(arguments) do
     arguments
     |> Credo.Code.Block.do_block_for!()
     |> abc_size_for(arguments, excluded_functions)
   end
 
   @doc false
   def abc_size_for(nil, _arguments, _excluded_functions), do: 0
 
   def abc_size_for(ast, arguments, excluded_functions) do
     initial_acc = [a: 0, b: 0, c: 0, var_names: get_parameters(arguments)]
 
     [a: a, b: b, c: c, var_names: _] =
       Credo.Code.prewalk(ast, &traverse_abc(&1, &2, excluded_functions), initial_acc)
 
     :math.sqrt(a * a + b * b + c * c)
   end
 
   defp get_parameters(arguments) do
     case Enum.at(arguments, 0) do
       {_name, _meta, nil} ->
         []
 
       {_name, _meta, parameters} ->
         Enum.map(parameters, &var_name/1)
     end
   end
 
   for op <- @def_ops do
     defp traverse_abc({unquote(op), _, arguments} = ast, abc, _excluded_functions)
          when is_list(arguments) do
       {ast, abc}
     end
   end
 
   # Ignore string interpolation
   defp traverse_abc({:<<>>, _, _}, acc, _excluded_functions) do
     {nil, acc}
   end
 
   # A - assignments
   defp traverse_abc(
          {:=, _meta, [lhs | rhs]},
          [a: a, b: b, c: c, var_names: var_names],
          _excluded_functions
        ) do
     var_names =
       case var_name(lhs) do
         nil ->
           var_names
 
         false ->
           var_names
 
         name ->
           var_names ++ [name]
       end
 
     {rhs, [a: a + 1, b: b, c: c, var_names: var_names]}
   end
 
   # B - branch
   defp traverse_abc(
          {:->, _meta, arguments} = ast,
          [a: a, b: b, c: c, var_names: var_names],
          _excluded_functions
        ) do
     var_names = var_names ++ fn_parameters(arguments)
     {ast, [a: a, b: b + 1, c: c, var_names: var_names]}
   end
 
   for op <- @branch_ops do
     defp traverse_abc(
            {unquote(op), _meta, [{_, _, nil}, _] = arguments} = ast,
            [a: a, b: b, c: c, var_names: var_names],
            _excluded_functions
          )
          when is_list(arguments) do
       {ast, [a: a, b: b, c: c, var_names: var_names]}
     end
 
     defp traverse_abc(
            {unquote(op), _meta, arguments} = ast,
            [a: a, b: b, c: c, var_names: var_names],
            _excluded_functions
          )
          when is_list(arguments) do
       {ast, [a: a, b: b + 1, c: c, var_names: var_names]}
     end
   end
 
   defp traverse_abc(
          {fun_name, _meta, arguments} = ast,
          [a: a, b: b, c: c, var_names: var_names],
          excluded_functions
        )
        when is_atom(fun_name) and fun_name not in @non_calls and is_list(arguments) do
     if Enum.member?(excluded_functions, to_string(fun_name)) do
       {nil, [a: a, b: b, c: c, var_names: var_names]}
     else
       {ast, [a: a, b: b + 1, c: c, var_names: var_names]}
     end
   end
 
   defp traverse_abc(
          {fun_or_var_name, _meta, nil} = ast,
          [a: a, b: b, c: c, var_names: var_names],
          _excluded_functions
        ) do
     is_variable = Enum.member?(var_names, fun_or_var_name)
 
     if is_variable do
       {ast, [a: a, b: b, c: c, var_names: var_names]}
     else
       {ast, [a: a, b: b + 1, c: c, var_names: var_names]}
     end
   end
 
   # C - conditions
   for op <- @condition_ops do
     defp traverse_abc(
            {unquote(op), _meta, arguments} = ast,
            [a: a, b: b, c: c, var_names: var_names],
            _excluded_functions
          )
          when is_list(arguments) do
       {ast, [a: a, b: b, c: c + 1, var_names: var_names]}
     end
   end
 
   defp traverse_abc(ast, abc, _excluded_functions) do
     {ast, abc}
   end
 
   defp var_name({name, _, nil}) when is_atom(name), do: name
   defp var_name(_), do: nil
 
   defp fn_parameters([params, tuple]) when is_list(params) and is_tuple(tuple) do
     fn_parameters(params)
   end
 
   defp fn_parameters([[{:when, _, params}], _]) when is_list(params) do
     fn_parameters(params)
   end
 
   defp fn_parameters(params) when is_list(params) do
     params
     |> Enum.map(&var_name/1)
     |> Enum.reject(&is_nil/1)
   end
 
   defp issue_for(issue_meta, line_no, trigger, max_value, actual_value) do
     format_issue(
       issue_meta,
       message: "Function is too complex (ABC size is #{actual_value}, max is #{max_value}).",
       trigger: trigger,
       line_no: line_no,
       severity: Severity.compute(actual_value, max_value)
     )
   end
 end