chore: introduce num42_refactors + apply safe AST refactors

.refactor.exs

@@ -0,0 +1,36 @@
+%{
+  inputs: ["lib/**/*.ex", "test/**/*.exs"],
+  configured_modules: [],
+  skipped_modules: [
+    # Re-renames identifiers without scope-awareness: collapses two distinct
+    # variables in the same scope (e.g. base_val + head_val) into a single
+    # shadowed name, silently breaking semantics. Also fights manual rename
+    # decisions on each rerun (avg_us → microseconds → microseconds collision).
+    # Track upstream issue before re-enabling.
+    Number42.Refactors.Ex.ExpandShortFormBindings,
+
+    # Loses guard conditions in transit. Example: rewrites
+    #   if next == nil do
+    #     if total > 0 and ratio > 0.6, do: vote, else: nothing
+    #   else
+    #     nothing
+    #   end
+    # to a cond block whose first arm is `compute_total.() -> vote`
+    # (i.e. just "any positive total casts a vote") — the original
+    # guard `ratio > 0.6` and the outer `next == nil` precondition
+    # are simply dropped. Produced 2 test failures in
+    # data_signal_test.exs on first try.
+    Number42.Refactors.Ex.IfElseToCond,
+
+    # Sorts def/defp groups alphabetically across the entire module.
+    # On this codebase that touches 121 files at once, deletes
+    # `# --- GenServer callbacks ---` / `# --- Private helpers ---`
+    # section comments, mixes public-API/impl-callbacks/private helpers
+    # into one alphabetical block, and splits some same-name clauses
+    # apart (compile warning: "clauses ... should be grouped together").
+    # Tests still pass but the resulting diff is unreviewable and the
+    # imposed order disagrees with the project's prior structural
+    # organisation (public first, then impl callbacks, then private).
+    Number42.Refactors.Ex.SortFunctions
+  ]
+}

lib/code_qa.ex

@@ -12,7 +12,5 @@ defmodule CodeQA do
       :world
 
   """
-  def hello do
-    :world
-  end
+  def hello, do: :world
 end

lib/codeqa/analysis/behavior_config_server.ex

@@ -18,9 +18,7 @@ defmodule CodeQA.Analysis.BehaviorConfigServer do
   # --- Public API ---
 
   @spec start_link(keyword()) :: GenServer.on_start()
-  def start_link(opts \\ []) do
-    GenServer.start_link(__MODULE__, opts)
-  end
+  def start_link(opts \\ []), do: __MODULE__ |> GenServer.start_link(opts)
 
   @doc "Returns the ETS table id. Callers may read directly from it."
   @spec get_tid(pid()) :: :ets.tid()
@@ -74,23 +72,11 @@ defmodule CodeQA.Analysis.BehaviorConfigServer do
   end
 
   @impl true
-  def handle_call(:get_tid, _from, state) do
-    {:reply, state.tid, state}
-  end
+  def handle_call(:get_tid, _from, state), do: {:reply, state.tid, state}
 
   # --- Private helpers ---
 
-  defp load_configs(tid) do
-    case File.ls(@yaml_dir) do
-      {:ok, files} ->
-        files
-        |> Enum.filter(&String.ends_with?(&1, ".yml"))
-        |> Enum.each(&load_yml_file(&1, tid))
-
-      {:error, _} ->
-        :ok
-    end
-  end
+  defp load_configs(tid), do: File.ls(@yaml_dir) |> handle_load_configs_ls(tid)
 
   defp load_yml_file(yml_file, tid) do
     category = String.trim_trailing(yml_file, ".yml")
@@ -109,11 +95,21 @@ defmodule CodeQA.Analysis.BehaviorConfigServer do
     behavior_data
     |> Enum.flat_map(fn
       {group, keys} when is_map(keys) ->
-        Enum.map(keys, fn {key, scalar} -> {{group, key}, scalar / 1.0} end)
+        keys |> Enum.map(fn {key, scalar} -> {{group, key}, scalar / 1.0} end)
 
       _ ->
         []
     end)
     |> Map.new()
   end
+
+  # FIXME: extracted automatically by ExtractCaseToHelper — review
+  # the parameter list and consider a better name.
+  defp handle_load_configs_ls({:ok, files}, tid),
+    do:
+      files
+      |> Enum.filter(&String.ends_with?(&1, ".yml"))
+      |> Enum.each(&load_yml_file(&1, tid))
+
+  defp handle_load_configs_ls({:error, _}, _tid), do: :ok
 end

lib/codeqa/analysis/file_context_server.ex

@@ -16,16 +16,15 @@ defmodule CodeQA.Analysis.FileContextServer do
 
   use GenServer
 
-  alias CodeQA.Engine.{FileContext, Pipeline}
+  alias CodeQA.Engine.FileContext
+  alias CodeQA.Engine.Pipeline
   alias CodeQA.Language
   alias CodeQA.Languages.Unknown
 
   # --- Public API ---
 
   @spec start_link(keyword()) :: GenServer.on_start()
-  def start_link(opts \\ []) do
-    GenServer.start_link(__MODULE__, opts)
-  end
+  def start_link(opts \\ []), do: __MODULE__ |> GenServer.start_link(opts)
 
   @doc "Returns the ETS table id. Callers may read directly from it."
   @spec get_tid(pid()) :: :ets.tid()
@@ -44,13 +43,13 @@ defmodule CodeQA.Analysis.FileContextServer do
     key = {md5(content), language_name}
 
     case :ets.lookup(tid, key) do
-      [{_, ctx}] ->
-        ctx
+      [{_, context}] ->
+        context
 
       [] ->
-        ctx = Pipeline.build_file_context(content, opts)
-        :ets.insert(tid, {key, ctx})
-        ctx
+        context = Pipeline.build_file_context(content, opts)
+        :ets.insert(tid, {key, context})
+        context
     end
   end
 
@@ -63,9 +62,7 @@ defmodule CodeQA.Analysis.FileContextServer do
   end
 
   @impl true
-  def handle_call(:get_tid, _from, state) do
-    {:reply, state.tid, state}
-  end
+  def handle_call(:get_tid, _from, state), do: {:reply, state.tid, state}
 
   # --- Private helpers ---
 

lib/codeqa/analysis/file_metrics_server.ex

@@ -18,9 +18,7 @@ defmodule CodeQA.Analysis.FileMetricsServer do
   # --- Public API ---
 
   @spec start_link(keyword()) :: GenServer.on_start()
-  def start_link(opts \\ []) do
-    GenServer.start_link(__MODULE__, opts)
-  end
+  def start_link(opts \\ []), do: __MODULE__ |> GenServer.start_link(opts)
 
   @doc "Returns the ETS table id. Callers may read directly from it."
   @spec get_tid(pid()) :: :ets.tid()
@@ -37,12 +35,14 @@ defmodule CodeQA.Analysis.FileMetricsServer do
     tid = get_tid(pid)
     files_data = Map.get(pipeline_result, "files", %{})
 
-    Enum.each(files_data, fn {path, file_data} ->
+    files_data
+    |> Enum.each(fn {path, file_data} ->
       metrics = Map.get(file_data, "metrics", %{})
       :ets.insert(tid, {{:path, path}, metrics})
     end)
 
-    Enum.each(files_map, fn {path, content} ->
+    files_map
+    |> Enum.each(fn {path, content} ->
       hash = md5(content)
 
       case :ets.lookup(tid, {:path, path}) do
@@ -81,8 +81,8 @@ defmodule CodeQA.Analysis.FileMetricsServer do
         metrics
 
       [] ->
-        ctx = Pipeline.build_file_context(content, opts)
-        metrics = Registry.run_file_metrics(registry, ctx)
+        context = Pipeline.build_file_context(content, opts)
+        metrics = Registry.run_file_metrics(registry, context)
         :ets.insert(tid, {{:hash, hash}, metrics})
         metrics
     end
@@ -97,9 +97,7 @@ defmodule CodeQA.Analysis.FileMetricsServer do
   end
 
   @impl true
-  def handle_call(:get_tid, _from, state) do
-    {:reply, state.tid, state}
-  end
+  def handle_call(:get_tid, _from, state), do: {:reply, state.tid, state}
 
   # --- Private helpers ---
 

lib/codeqa/analysis/run_supervisor.ex

@@ -11,12 +11,12 @@ defmodule CodeQA.Analysis.RunSupervisor do
 
   use Supervisor
 
-  alias CodeQA.Analysis.{BehaviorConfigServer, FileContextServer, RunContext}
+  alias CodeQA.Analysis.BehaviorConfigServer
+  alias CodeQA.Analysis.FileContextServer
+  alias CodeQA.Analysis.RunContext
 
   @spec start_link(keyword()) :: Supervisor.on_start()
-  def start_link(opts \\ []) do
-    Supervisor.start_link(__MODULE__, opts)
-  end
+  def start_link(opts \\ []), do: __MODULE__ |> Supervisor.start_link(opts)
 
   @doc """
   Queries child PIDs from `sup` and returns a `RunContext` struct.
@@ -45,7 +45,7 @@ defmodule CodeQA.Analysis.RunSupervisor do
 
   defp find_pid(children, module) do
     {_id, pid, _type, _modules} =
-      Enum.find(children, fn {id, _pid, _type, _modules} -> id == module end)
+      children |> Enum.find(fn {id, _pid, _type, _modules} -> id == module end)
 
     pid
   end

lib/codeqa/ast/classification/node_classifier.ex

@@ -36,26 +36,22 @@ defmodule CodeQA.AST.Classification.NodeClassifier do
 
   alias CodeQA.AST.Enrichment.Node
 
-  alias CodeQA.AST.Nodes.{
-    AttributeNode,
-    CodeNode,
-    DocNode,
-    FunctionNode,
-    ImportNode,
-    ModuleNode,
-    TestNode
-  }
+  alias CodeQA.AST.Nodes.AttributeNode
+  alias CodeQA.AST.Nodes.CodeNode
+  alias CodeQA.AST.Nodes.DocNode
+  alias CodeQA.AST.Nodes.FunctionNode
+  alias CodeQA.AST.Nodes.ImportNode
+  alias CodeQA.AST.Nodes.ModuleNode
+  alias CodeQA.AST.Nodes.TestNode
 
   alias CodeQA.AST.Parsing.SignalStream
 
-  alias CodeQA.AST.Signals.Classification.{
-    AttributeSignal,
-    DocSignal,
-    FunctionSignal,
-    ImportSignal,
-    ModuleSignal,
-    TestSignal
-  }
+  alias CodeQA.AST.Signals.Classification.AttributeSignal
+  alias CodeQA.AST.Signals.Classification.DocSignal
+  alias CodeQA.AST.Signals.Classification.FunctionSignal
+  alias CodeQA.AST.Signals.Classification.ImportSignal
+  alias CodeQA.AST.Signals.Classification.ModuleSignal
+  alias CodeQA.AST.Signals.Classification.TestSignal
 
   @classification_signals [
     %DocSignal{},
@@ -67,13 +63,13 @@ defmodule CodeQA.AST.Classification.NodeClassifier do
   ]
 
   @type_modules %{
-    doc: DocNode,
     attribute: AttributeNode,
+    code: CodeNode,
+    doc: DocNode,
     function: FunctionNode,
-    module: ModuleNode,
     import: ImportNode,
-    test: TestNode,
-    code: CodeNode
+    module: ModuleNode,
+    test: TestNode
   }
 
   @doc """
@@ -106,12 +102,12 @@ defmodule CodeQA.AST.Classification.NodeClassifier do
   defp prepend_context(tokens, []), do: tokens
   defp prepend_context(tokens, ctx) when is_list(ctx), do: ctx ++ tokens
 
-  defp vote(tokens, lang_mod) do
-    tokens
-    |> run_signals(lang_mod)
-    |> tally()
-    |> winner()
-  end
+  defp vote(tokens, lang_mod),
+    do:
+      tokens
+      |> run_signals(lang_mod)
+      |> tally()
+      |> winner()
 
   defp run_signals(tokens, lang_mod) do
     SignalStream.run(tokens, @classification_signals, lang_mod)
@@ -120,15 +116,16 @@ defmodule CodeQA.AST.Classification.NodeClassifier do
   end
 
   defp tally(emissions) do
-    Enum.reduce(emissions, %{}, fn {_src, _grp, name, weight}, acc ->
+    emissions
+    |> Enum.reduce(%{}, fn {_src, _grp, name, weight}, acc ->
       Map.update(acc, name, weight, &(&1 + weight))
     end)
   end
 
   defp winner(votes) when map_size(votes) == 0, do: :code
 
   defp winner(votes) do
-    {vote_name, _weight} = Enum.max_by(votes, fn {_, w} -> w end)
+    {vote_name, _weight} = votes |> Enum.max_by(fn {_, w} -> w end)
     vote_to_type(vote_name)
   end
 

lib/codeqa/ast/classification/node_type_detector.ex

@@ -14,7 +14,6 @@ defmodule CodeQA.AST.Classification.NodeTypeDetector do
   Classify each node in the list into the most specific typed struct.
   """
   @spec detect_types([Node.t()], module()) :: [term()]
-  def detect_types(blocks, lang_mod) do
-    Enum.map(blocks, &NodeClassifier.classify(&1, lang_mod))
-  end
+  def detect_types(blocks, lang_mod),
+    do: blocks |> Enum.map(&NodeClassifier.classify(&1, lang_mod))
 end

lib/codeqa/ast/classification/typed_node_kind.ex

@@ -1,15 +1,13 @@
 defmodule CodeQA.AST.Classification.TypedNodeKind do
   @moduledoc "Maps a typed node struct from `NodeClassifier` to its kind atom."
 
-  alias CodeQA.AST.Nodes.{
-    AttributeNode,
-    CodeNode,
-    DocNode,
-    FunctionNode,
-    ImportNode,
-    ModuleNode,
-    TestNode
-  }
+  alias CodeQA.AST.Nodes.AttributeNode
+  alias CodeQA.AST.Nodes.CodeNode
+  alias CodeQA.AST.Nodes.DocNode
+  alias CodeQA.AST.Nodes.FunctionNode
+  alias CodeQA.AST.Nodes.ImportNode
+  alias CodeQA.AST.Nodes.ModuleNode
+  alias CodeQA.AST.Nodes.TestNode
 
   @type kind :: :doc | :attribute | :function | :module | :import | :test | :code
 

lib/codeqa/ast/enrichment/compound_node.ex

@@ -21,21 +21,21 @@ defmodule CodeQA.AST.Enrichment.CompoundNode do
   alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Nodes.AttributeNode
 
-  defstruct docs: [],
-            typespecs: [],
-            code: [],
-            start_line: nil,
-            start_col: nil,
+  defstruct code: [],
+            docs: [],
+            end_col: nil,
             end_line: nil,
-            end_col: nil
+            start_col: nil,
+            start_line: nil,
+            typespecs: []
 
   @type t :: %__MODULE__{
-          docs: [Node.t()],
-          typespecs: [AttributeNode.t()],
           code: [Node.t()],
-          start_line: non_neg_integer() | nil,
-          start_col: non_neg_integer() | nil,
+          docs: [Node.t()],
+          end_col: non_neg_integer() | nil,
           end_line: non_neg_integer() | nil,
-          end_col: non_neg_integer() | nil
+          start_col: non_neg_integer() | nil,
+          start_line: non_neg_integer() | nil,
+          typespecs: [AttributeNode.t()]
         }
 end