credo

0.10.2

1.7.19 1.7.18 1.7.17 1.7.16 1.7.15 1.7.14 1.7.13 1.7.12 1.7.11 1.7.10 1.7.9 1.7.8 1.7.7 1.7.7-rc.0 1.7.6 1.7.5 1.7.4 1.7.3 1.7.2 1.7.2-rc.4 1.7.2-rc.3 1.7.2-rc.2 1.7.2-rc.1 1.7.2-rc.0 1.7.1 1.7.0 1.7.0-rc.2 1.7.0-rc.1 1.6.7 1.6.6 1.6.5 1.6.4 1.6.3 1.6.2 1.6.1 1.6.0 1.6.0-rc.1 1.6.0-rc.0 1.5.6 1.5.5 1.5.4 1.5.3 1.5.2 1.5.1 1.5.0 1.5.0-rc.5 1.5.0-rc.4 1.5.0-rc.3 1.5.0-rc.2 1.5.0-rc.1 1.4.1 1.4.0 1.4.0-rc.2 1.4.0-rc.1 1.3.2 1.3.1 1.3.0 1.3.0-rc3 1.3.0-rc2 1.3.0-rc1 1.2.3 1.2.2 1.2.1 1.2.0 1.2.0-rc4 1.2.0-rc3 1.2.0-rc2 1.2.0-rc1 1.1.5 1.1.4 1.1.3 1.1.2 1.1.1 1.1.0 1.1.0-rc3 1.1.0-rc2 1.1.0-rc1 1.0.5 1.0.4 1.0.3 1.0.2 1.0.1 1.0.1-rc1 1.0.0 1.0.0-rc1 0.10.2 0.10.1 0.10.0 0.9.3 0.9.2 0.9.1 0.9.0 0.9.0-rc8 0.9.0-rc7 0.9.0-rc6 0.9.0-rc5 0.9.0-rc4 0.9.0-rc3 0.9.0-rc2 0.9.0-rc1 0.8.10 0.8.9 0.8.8 0.8.7 0.8.6 0.8.5 0.8.4 0.8.3 0.8.2 0.8.1 0.8.0 0.8.0-rc7 0.8.0-rc6 0.8.0-rc5 0.8.0-rc4 0.8.0-rc3 0.8.0-rc2 0.8.0-rc1 0.7.4 0.7.3 0.7.2 0.7.1 0.7.0 0.6.1 0.6.0 0.6.0-rc2 0.6.0-rc1 0.5.3 0.5.2 0.5.1 0.5.0 0.4.14 0.4.13 0.4.12 0.4.11 0.4.10 0.4.10-dev 0.4.9 0.4.8 0.4.7 0.4.6 0.4.5 0.4.4 0.4.3 0.4.2 0.4.1 0.4.0 0.4.0-beta5 0.4.0-beta4 0.4.0-beta3 0.4.0-beta2 0.4.0-beta1 0.3.13 0.3.12 0.3.11 0.3.10 0.3.9 0.3.8 0.3.7 0.3.6 0.3.5 0.3.4 0.3.3 0.3.2 0.3.1 0.3.0 0.3.0-dev2 0.3.0-dev 0.2.6 0.2.5 0.2.4 0.2.3 0.2.2 0.2.1 0.2.0 0.1.10 0.1.9 0.1.8 0.1.7 0.1.6 0.1.5 0.1.4 0.1.3 0.1.2 0.1.1 0.1.0 0.0.1-dev

A static code analysis tool with a focus on code consistency and teaching.

HexDocs

Current section

Files

Jump to

Readme 187 Versions 2 Dependencies Dependants Files Activity

credo lib credo check refactor abc_size.ex

Raw

lib/credo/check/refactor/abc_size.ex

defmodule Credo.Check.Refactor.ABCSize do
  @moduledoc """
  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.
  """

  @explanation [
    check: @moduledoc,
    params: [
      max_size: "The maximum ABC size a function should have."
    ]
  ]
  @default_params [
    max_size: 30
  ]
  @def_ops [:def, :defp, :defmacro]
  @branch_ops [:.]
  @condition_ops [:if, :unless, :for, :try, :case, :cond, :and, :or, :&&, :||]

  use Credo.Check

  alias Credo.Check.CodeHelper

  @doc false
  def run(source_file, params \\ []) do
    issue_meta = IssueMeta.for(source_file, params)
    max_abc_size = Params.get(params, :max_size, @default_params)

    Credo.Code.prewalk(source_file, &traverse(&1, &2, issue_meta, max_abc_size))
  end

  defp traverse({:defmacro, _, [{:__using__, _, _}, _]} = ast, issues, _, _) do
    {ast, issues}
  end

  for op <- @def_ops do
    defp traverse(
           {unquote(op), meta, arguments} = ast,
           issues,
           issue_meta,
           max_abc_size
         )
         when is_list(arguments) do
      abc_size =
        ast
        |> abc_size_for
        |> round

      if abc_size > max_abc_size do
        fun_name = CodeHelper.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) 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}) when is_list(arguments) do
    arguments
    |> CodeHelper.do_block_for!()
    |> abc_size_for(arguments)
  end

  @doc false
  def abc_size_for(nil, _arguments), do: 0

  def abc_size_for(ast, arguments) 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/2, initial_acc)

    :math.sqrt(a * a + b * b + c * c)
  end

  def 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)
         when is_list(arguments) do
      {ast, abc}
    end
  end

  # Ignore string interpolation
  defp traverse_abc({:<<>>, _, _}, acc) do
    {nil, acc}
  end

  # A - assignments
  defp traverse_abc(
         {:=, _meta, [lhs | rhs]},
         a: a,
         b: b,
         c: c,
         var_names: var_names
       ) do
    var_names =
      case var_name(lhs) do
        nil ->
          var_names

        false ->
          var_names

        name ->
          Enum.into(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
       ) do
    var_names = Enum.into(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
         )
         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
         )
         when is_list(arguments) do
      {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
       ) 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
         )
         when is_list(arguments) do
      {ast, [a: a, b: b, c: c + 1, var_names: var_names]}
    end
  end

  defp traverse_abc(ast, abc) do
    {ast, abc}
  end

  defp var_name({name, _, nil}) when is_atom(name), do: name
  defp var_name(_), do: nil

  def fn_parameters([params, tuple]) when is_list(params) and is_tuple(tuple) do
    fn_parameters(params)
  end

  def fn_parameters([[{:when, _, params}], _]) when is_list(params) do
    fn_parameters(params)
  end

  def fn_parameters(params) when is_list(params) do
    params
    |> Enum.map(&var_name/1)
    |> Enum.reject(&is_nil/1)
  end

  def 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

Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT