refactor: Improve code organization with module aliases

Fixed all 30 Credo software design suggestions by adding proper module
aliases and using short names throughout the codebase. This improves
code readability and maintainability.

Changes:
- Added aliases in process_superviser.ex for Cleanup, Config, Error,
  Telemetry, and SessionRegistry
- Added aliases in cleanup.ex for Config, Helpers, ProcessSupervisor,
  and Telemetry
- Added aliases in helpers.ex for Config and SessionRegistry
- Added aliases in main phoenix/session_process.ex for Config,
  ProcessSupervisor, and SessionRegistry
- Added alias in test_process.ex for State
- Added alias in session_process_test.exs for SessionId
- Added alias in state_test.exs for Redux
- Replaced all nested module references with short alias names
- Used unquote() in macros to properly expand aliases

All 65 tests passing. Credo reports no issues.

Author: GSMLG-BOT

lib/phoenix/session_process.ex

@@ -148,6 +148,9 @@ defmodule Phoenix.SessionProcess do
   See the benchmarking guide at `bench/README.md` for details.
   """
 
+  alias Phoenix.SessionProcess.{Config, ProcessSupervisor}
+  alias Phoenix.SessionProcess.Registry, as: SessionRegistry
+
   @doc """
   Starts a session process using the default configured module.
 
@@ -350,7 +353,7 @@ defmodule Phoenix.SessionProcess do
   """
   @spec list_session :: [{binary(), pid()}, ...]
   def list_session do
-    Registry.select(Phoenix.SessionProcess.Registry, [
+    Registry.select(SessionRegistry, [
       {{:":$1", :":$2", :_}, [], [{{:":$1", :":$2"}}]}
     ])
   end
@@ -379,9 +382,9 @@ defmodule Phoenix.SessionProcess do
     modules =
       sessions
       |> Enum.map(fn {_session_id, pid} ->
-        case Registry.lookup(Phoenix.SessionProcess.Registry, pid) do
+        case Registry.lookup(SessionRegistry, pid) do
           [{_, module}] -> module
-          _ -> Phoenix.SessionProcess.Config.session_process()
+          _ -> Config.session_process()
         end
       end)
       |> Enum.uniq()
@@ -413,7 +416,7 @@ defmodule Phoenix.SessionProcess do
   """
   @spec list_sessions_by_module(module()) :: [binary()]
   def list_sessions_by_module(module) do
-    Registry.select(Phoenix.SessionProcess.Registry, [
+    Registry.select(SessionRegistry, [
       {{:"$1", :"$2", :"$_"}, [], [{{:"$1", :"$2", :"$_"}}]}
     ])
     |> Enum.filter(fn {_session_id, _pid, mod} -> mod == module end)
@@ -446,7 +449,7 @@ defmodule Phoenix.SessionProcess do
   """
   @spec find_session(binary()) :: {:ok, pid()} | {:error, :not_found}
   def find_session(session_id) do
-    case Phoenix.SessionProcess.ProcessSupervisor.session_process_pid(session_id) do
+    case ProcessSupervisor.session_process_pid(session_id) do
       nil -> {:error, :not_found}
       pid -> {:ok, pid}
     end
@@ -525,7 +528,7 @@ defmodule Phoenix.SessionProcess do
       def get_session_id do
         current_pid = self()
 
-        Registry.select(Phoenix.SessionProcess.Registry, [
+        Registry.select(unquote(SessionRegistry), [
           {{:":$1", :":$2", :_}, [{:==, :":$2", current_pid}], [{{:":$1", :":$2"}}]}
         ])
         |> Enum.at(0)
@@ -547,7 +550,7 @@ defmodule Phoenix.SessionProcess do
       def get_session_id do
         current_pid = self()
 
-        Registry.select(Phoenix.SessionProcess.Registry, [
+        Registry.select(unquote(SessionRegistry), [
           {{:":$1", :":$2", :_}, [{:==, :":$2", current_pid}], [{{:":$1", :":$2"}}]}
         ])
         |> Enum.at(0)

lib/phoenix/session_process/cleanup.ex

@@ -74,6 +74,8 @@ defmodule Phoenix.SessionProcess.Cleanup do
   use GenServer
   require Logger
 
+  alias Phoenix.SessionProcess.{Config, Helpers, ProcessSupervisor, Telemetry}
+
   # 1 minute
   @cleanup_interval 60_000
 
@@ -96,12 +98,12 @@ defmodule Phoenix.SessionProcess.Cleanup do
 
   @impl true
   def handle_info({:cleanup_session, session_id}, state) do
-    if Phoenix.SessionProcess.ProcessSupervisor.session_process_started?(session_id) do
-      session_pid = Phoenix.SessionProcess.ProcessSupervisor.session_process_pid(session_id)
+    if ProcessSupervisor.session_process_started?(session_id) do
+      session_pid = ProcessSupervisor.session_process_pid(session_id)
 
-      Phoenix.SessionProcess.Telemetry.emit_auto_cleanup_event(
+      Telemetry.emit_auto_cleanup_event(
         session_id,
-        Phoenix.SessionProcess.Helpers.get_session_module(session_pid),
+        Helpers.get_session_module(session_pid),
         session_pid
       )
 
@@ -126,7 +128,7 @@ defmodule Phoenix.SessionProcess.Cleanup do
   """
   @spec schedule_session_cleanup(binary()) :: :ok
   def schedule_session_cleanup(session_id) do
-    ttl = Phoenix.SessionProcess.Config.session_ttl()
+    ttl = Config.session_ttl()
     Process.send_after(__MODULE__, {:cleanup_session, session_id}, ttl)
     :ok
   end

lib/phoenix/session_process/helpers.ex

@@ -7,6 +7,8 @@ defmodule Phoenix.SessionProcess.Helpers do
   """
 
   alias Phoenix.SessionProcess
+  alias Phoenix.SessionProcess.Config
+  alias Phoenix.SessionProcess.Registry, as: SessionRegistry
 
   @doc """
   Start sessions for multiple session IDs in parallel.
@@ -183,9 +185,9 @@ defmodule Phoenix.SessionProcess.Helpers do
   """
   @spec get_session_module(pid()) :: module()
   def get_session_module(pid) do
-    case Registry.lookup(Phoenix.SessionProcess.Registry, pid) do
+    case Registry.lookup(SessionRegistry, pid) do
       [{_, module}] -> module
-      _ -> Phoenix.SessionProcess.Config.session_process()
+      _ -> Config.session_process()
     end
   end
 end

lib/phoenix/session_process/process_superviser.ex

@@ -85,7 +85,8 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
   # Automatically defines child_spec/1
   use DynamicSupervisor
 
-  alias Phoenix.SessionProcess.{Error, Telemetry}
+  alias Phoenix.SessionProcess.{Cleanup, Config, Error, Telemetry}
+  alias Phoenix.SessionProcess.Registry, as: SessionRegistry
 
   @doc """
   Starts the process supervisor.
@@ -126,7 +127,7 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
   """
   def start_child(worker, worker_arg) do
     worker_spec = {worker, worker_arg}
-    Phoenix.SessionProcess.Telemetry.emit_worker_start(worker_spec)
+    Telemetry.emit_worker_start(worker_spec)
     DynamicSupervisor.start_child(__MODULE__, worker_spec)
   end
 
@@ -143,7 +144,7 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
   - `{:error, reason}` - Failed to terminate child process
   """
   def terminate_child(pid) do
-    Phoenix.SessionProcess.Telemetry.emit_worker_terminate(pid)
+    Telemetry.emit_worker_terminate(pid)
     DynamicSupervisor.terminate_child(__MODULE__, pid)
   end
 
@@ -176,7 +177,7 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
   - `{:error, reason}` - Failed to start session process
   """
   def start_session(session_id) do
-    start_session_with_module(session_id, Phoenix.SessionProcess.Config.session_process())
+    start_session_with_module(session_id, Config.session_process())
   end
 
   @doc """
@@ -255,7 +256,7 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
   """
   @spec terminate_session(binary()) :: :ok | {:error, :not_found}
   def terminate_session(session_id) do
-    Phoenix.SessionProcess.Telemetry.emit_session_end_event(session_id)
+    Telemetry.emit_session_end_event(session_id)
     start_time = System.monotonic_time()
 
     case session_process_pid(session_id) do
@@ -338,14 +339,14 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
       Error.cast_failed(module, :cast, {request}, reason)
   end
 
-  @spec child_name(binary()) :: {:via, Registry, {Phoenix.SessionProcess.Registry, binary()}}
+  @spec child_name(binary()) :: {:via, Registry, {SessionRegistry, binary()}}
   def child_name(session_id) do
-    {:via, Registry, {Phoenix.SessionProcess.Registry, session_id}}
+    {:via, Registry, {SessionRegistry, session_id}}
   end
 
   @spec session_process_pid(binary()) :: nil | pid()
   def session_process_pid(session_id) do
-    case Registry.whereis_name({Phoenix.SessionProcess.Registry, session_id}) do
+    case Registry.whereis_name({SessionRegistry, session_id}) do
       :undefined -> nil
       pid -> pid
     end
@@ -356,7 +357,7 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
 
     with :ok <- validate_session_id(session_id),
          :ok <- check_session_limits() do
-      Phoenix.SessionProcess.Telemetry.emit_session_start_event(session_id)
+      Telemetry.emit_session_start_event(session_id)
 
       worker_args =
         if arg, do: [name: child_name(session_id), arg: arg], else: [name: child_name(session_id)]
@@ -365,15 +366,15 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
 
       case DynamicSupervisor.start_child(__MODULE__, spec) do
         {:ok, pid} = result ->
-          Registry.register(Phoenix.SessionProcess.Registry, pid, module)
-          Phoenix.SessionProcess.Cleanup.schedule_session_cleanup(session_id)
+          Registry.register(SessionRegistry, pid, module)
+          Cleanup.schedule_session_cleanup(session_id)
           duration = System.monotonic_time() - start_time
           Telemetry.emit_session_start(session_id, module, pid, duration: duration)
           result
 
         {:ok, pid, _info} = result ->
-          Registry.register(Phoenix.SessionProcess.Registry, pid, module)
-          Phoenix.SessionProcess.Cleanup.schedule_session_cleanup(session_id)
+          Registry.register(SessionRegistry, pid, module)
+          Cleanup.schedule_session_cleanup(session_id)
           duration = System.monotonic_time() - start_time
           Telemetry.emit_session_start(session_id, module, pid, duration: duration)
           result
@@ -399,7 +400,7 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
         Error.invalid_session_id(session_id)
 
       {:error, :session_limit_reached} ->
-        max_sessions = Phoenix.SessionProcess.Config.max_sessions()
+        max_sessions = Config.max_sessions()
         duration = System.monotonic_time() - start_time
 
         Telemetry.emit_session_start_error(
@@ -414,23 +415,23 @@ defmodule Phoenix.SessionProcess.ProcessSupervisor do
   end
 
   defp get_session_module(pid) do
-    case Registry.lookup(Phoenix.SessionProcess.Registry, pid) do
+    case Registry.lookup(SessionRegistry, pid) do
       [{_, module}] -> module
-      _ -> Phoenix.SessionProcess.Config.session_process()
+      _ -> Config.session_process()
     end
   end
 
   defp validate_session_id(session_id) do
-    if Phoenix.SessionProcess.Config.valid_session_id?(session_id) do
+    if Config.valid_session_id?(session_id) do
       :ok
     else
       {:error, :invalid_session_id}
     end
   end
 
   defp check_session_limits do
-    max_sessions = Phoenix.SessionProcess.Config.max_sessions()
-    current_sessions = Registry.count(Phoenix.SessionProcess.Registry)
+    max_sessions = Config.max_sessions()
+    current_sessions = Registry.count(SessionRegistry)
 
     if current_sessions < max_sessions do
       :ok

test/phoenix/session_process/state_test.exs

@@ -1,6 +1,6 @@
 defmodule Phoenix.SessionProcess.StateTest do
   use ExUnit.Case, async: true
-  alias Phoenix.SessionProcess.State
+  alias Phoenix.SessionProcess.{Redux, State}
 
   describe "start_link/1" do
     test "starts with default state" do
@@ -199,14 +199,14 @@ defmodule Phoenix.SessionProcess.StateTest do
       {:ok, pid} = State.start_link(%{redux: nil})
 
       # This tests the interaction pattern
-      redux = Phoenix.SessionProcess.Redux.init_state(%{count: 0})
+      redux = Redux.init_state(%{count: 0})
       reducer = fn state, {:increment, val} -> %{state | count: state.count + val} end
 
-      new_redux = Phoenix.SessionProcess.Redux.dispatch(redux, {:increment, 5}, reducer)
+      new_redux = Redux.dispatch(redux, {:increment, 5}, reducer)
       State.update_state(pid, fn _ -> %{redux: new_redux} end)
 
       state = State.get_state(pid)
-      assert Phoenix.SessionProcess.Redux.current_state(state.redux).count == 5
+      assert Redux.current_state(state.redux).count == 5
     end
   end
 end

test/phoenix/session_process_test.exs

@@ -3,6 +3,7 @@ defmodule Phoenix.SessionProcessTest do
   # doctest Phoenix.SessionProcess  # Disabled to avoid test interference
 
   alias Phoenix.SessionProcess
+  alias Phoenix.SessionProcess.SessionId
 
   setup do
     # Ensure supervisor is started
@@ -25,29 +26,29 @@ defmodule Phoenix.SessionProcessTest do
   end
 
   test "test start session process" do
-    session_id = Phoenix.SessionProcess.SessionId.generate_unique_session_id()
+    session_id = SessionId.generate_unique_session_id()
     assert SessionProcess.started?(session_id) == false
     {:ok, pid} = SessionProcess.start(session_id, TestProcess, %{value: 0})
     assert is_pid(pid)
     assert SessionProcess.started?(session_id) == true
   end
 
   test "test terminate session process" do
-    session_id = Phoenix.SessionProcess.SessionId.generate_unique_session_id()
+    session_id = SessionId.generate_unique_session_id()
     {:ok, _pid} = SessionProcess.start(session_id, TestProcess, %{value: 0})
     assert SessionProcess.started?(session_id) == true
     SessionProcess.terminate(session_id)
     assert SessionProcess.started?(session_id) == false
   end
 
   test "test call on session process" do
-    session_id = Phoenix.SessionProcess.SessionId.generate_unique_session_id()
+    session_id = SessionId.generate_unique_session_id()
     {:ok, _pid} = SessionProcess.start(session_id, TestProcess, %{value: 123})
     assert SessionProcess.call(session_id, :get_value) == 123
   end
 
   test "test cast on session process" do
-    session_id = Phoenix.SessionProcess.SessionId.generate_unique_session_id()
+    session_id = SessionId.generate_unique_session_id()
     {:ok, _pid} = SessionProcess.start(session_id, TestProcess, %{value: 0})
     assert SessionProcess.call(session_id, :get_value) == 0
     SessionProcess.cast(session_id, :add_one)

test/support/test_process.ex

@@ -8,21 +8,23 @@ defmodule TestProcess do
 
   use Phoenix.SessionProcess, :process
 
+  alias Phoenix.SessionProcess.State
+
   @impl true
   def init(init_arg \\ %{}) do
-    {:ok, agent} = Phoenix.SessionProcess.State.start_link(init_arg)
+    {:ok, agent} = State.start_link(init_arg)
     {:ok, %{agent: agent}}
   end
 
   @impl true
   def handle_call(:get_value, _from, state) do
-    {:reply, Phoenix.SessionProcess.State.get(state.agent, :value), state}
+    {:reply, State.get(state.agent, :value), state}
   end
 
   @impl true
   def handle_cast(:add_one, state) do
-    value = Phoenix.SessionProcess.State.get(state.agent, :value)
-    Phoenix.SessionProcess.State.put(state.agent, :value, value + 1)
+    value = State.get(state.agent, :value)
+    State.put(state.agent, :value, value + 1)
     {:noreply, state}
   end
 end