refactor project_populator

Author: NSHkr

lib/elixir_scope/ast_repository/enhanced/project_populator.ex

@@ -0,0 +1,99 @@
+defmodule ElixirScope.ASTRepository.Enhanced.ProjectPopulator.ASTExtractor do
+  @moduledoc """
+  Extracts information from AST structures.
+
+  Provides functionality to:
+  - Extract module names from AST
+  - Extract functions from modules
+  - Extract dependencies, exports, and attributes
+  """
+
+  @doc """
+  Extracts module name from AST.
+  """
+  def extract_module_name(ast) do
+    case ast do
+      {:defmodule, _, [module_alias, _body]} ->
+        case module_alias do
+          {:__aliases__, _, parts} -> Module.concat(parts)
+          atom when is_atom(atom) -> atom
+          _ -> nil
+        end
+      _ -> nil
+    end
+  end
+
+  @doc """
+  Extracts functions from module AST.
+  """
+  def extract_functions_from_module(ast) do
+    case ast do
+      {:defmodule, _, [_module_name, [do: body]]} ->
+        extract_functions_from_body(body, [])
+      _ -> []
+    end
+  end
+
+  @doc """
+  Extracts module dependencies from AST.
+  """
+  def extract_module_dependencies(_ast) do
+    # Extract alias, import, use, and require statements
+    dependencies = []
+
+    # This would be a more sophisticated implementation
+    # For now, return empty list
+    dependencies
+  end
+
+  @doc """
+  Extracts module exports from AST.
+  """
+  def extract_module_exports(_ast) do
+    # Extract @spec and public function definitions
+    exports = []
+
+    # This would be a more sophisticated implementation
+    # For now, return empty list
+    exports
+  end
+
+  @doc """
+  Extracts module attributes from AST.
+  """
+  def extract_module_attributes(_ast) do
+    # Extract module attributes like @moduledoc, @doc, @spec, etc.
+    attributes = %{}
+
+    # This would be a more sophisticated implementation
+    # For now, return empty map
+    attributes
+  end
+
+  # Private functions
+
+  defp extract_functions_from_body({:__block__, _, statements}, acc) do
+    Enum.reduce(statements, acc, &extract_function_from_statement/2)
+  end
+  defp extract_functions_from_body(statement, acc) do
+    extract_function_from_statement(statement, acc)
+  end
+
+  defp extract_function_from_statement({:def, meta, [{:when, _, [{name, _, args}, _guard]}, body]}, acc) do
+    arity = if is_list(args), do: length(args), else: 0
+    [{name, arity, {:def, meta, [{name, [], args || []}, body]}} | acc]
+  end
+  defp extract_function_from_statement({:defp, meta, [{:when, _, [{name, _, args}, _guard]}, body]}, acc) do
+    arity = if is_list(args), do: length(args), else: 0
+    [{name, arity, {:defp, meta, [{name, [], args || []}, body]}} | acc]
+  end
+  defp extract_function_from_statement({:def, meta, [{name, _, args}, body]}, acc) do
+    arity = if is_list(args), do: length(args), else: 0
+    [{name, arity, {:def, meta, [{name, [], args || []}, body]}} | acc]
+  end
+  defp extract_function_from_statement({:defp, meta, [{name, _, args}, body]}, acc) do
+    arity = if is_list(args), do: length(args), else: 0
+    [{name, arity, {:defp, meta, [{name, [], args || []}, body]}} | acc]
+  end
+  defp extract_function_from_statement(_, acc), do: acc
+end

lib/elixir_scope/ast_repository/enhanced/project_populator/ast_extractor.ex

@@ -0,0 +1,128 @@
+defmodule ElixirScope.ASTRepository.Enhanced.ProjectPopulator.ComplexityAnalyzer do
+  @moduledoc """
+  Analyzes complexity metrics for modules and functions.
+
+  Provides functionality to:
+  - Calculate module complexity metrics
+  - Calculate function complexity metrics
+  - Analyze performance characteristics
+  - Detect complexity patterns
+  """
+
+  @doc """
+  Calculates complexity metrics for a module.
+  """
+  def calculate_module_complexity_metrics(ast, functions) do
+    function_complexities = functions
+    |> Map.values()
+    |> Enum.map(fn func -> func.complexity_metrics.combined_complexity || 1.0 end)
+
+    %{
+      combined_complexity: Enum.sum(function_complexities),
+      average_function_complexity: if(length(function_complexities) > 0, do: Enum.sum(function_complexities) / length(function_complexities), else: 1.0),
+      max_function_complexity: Enum.max(function_complexities ++ [1.0]),
+      function_count: map_size(functions),
+      lines_of_code: count_ast_lines(ast)
+    }
+  end
+
+  @doc """
+  Calculates complexity metrics for a function.
+  """
+  def calculate_function_complexity_metrics(func_ast, cfg_data, dfg_data) do
+    cfg_complexity = if cfg_data, do: cfg_data.complexity_metrics.cyclomatic || 1, else: 1
+    # DFG doesn't have complexity metrics, calculate based on data flow complexity
+    dfg_complexity = if dfg_data do
+      # Calculate data flow complexity based on number of variables and flows
+      # Handle both map and list formats for variables (defensive programming)
+      variable_count = case dfg_data.variables do
+        variables when is_map(variables) -> map_size(variables)
+        variables when is_list(variables) -> length(variables)
+        nil -> 0
+        _ -> 0
+      end
+      flow_count = length(dfg_data.data_flows || [])
+      max(1, variable_count + flow_count)
+    else
+      1
+    end
+
+    %{
+      combined_complexity: Float.round(cfg_complexity * 0.7 + dfg_complexity * 0.3, 2),
+      cyclomatic_complexity: cfg_complexity,
+      data_flow_complexity: dfg_complexity,
+      cognitive_complexity: calculate_cognitive_complexity(func_ast),
+      nesting_depth: calculate_nesting_depth(func_ast)
+    }
+  end
+
+  @doc """
+  Analyzes performance characteristics of a function.
+  """
+  def analyze_function_performance_characteristics(func_ast, cfg_data, _dfg_data) do
+    # Simplified performance analysis
+    has_loops = detect_loops_in_ast(func_ast)
+    has_recursion = detect_recursion_in_ast(func_ast)
+    complexity = if cfg_data, do: cfg_data.complexity_metrics.cyclomatic || 1, else: 1
+
+    %{
+      has_issues: complexity > 10 or has_loops or has_recursion,
+      bottlenecks: [],
+      performance_score: max(0.0, 100.0 - complexity * 5),
+      optimization_potential: if(complexity > 5, do: :high, else: :low)
+    }
+  end
+
+  # Private functions
+
+  defp count_ast_lines(ast) do
+    # Simplified line counting from AST
+    # In practice, this would traverse the AST and count unique line numbers
+    50  # Placeholder
+  end
+
+  defp calculate_cognitive_complexity(_ast) do
+    # Simplified cognitive complexity calculation
+    5  # Placeholder
+  end
+
+  defp calculate_nesting_depth(ast) do
+    # Simplified nesting depth calculation
+    calculate_nesting_recursive(ast, 0)
+  end
+
+  defp calculate_nesting_recursive(ast, current_depth) do
+    case ast do
+      {:if, _, _} -> current_depth + 1
+      {:case, _, _} -> current_depth + 1
+      {:cond, _, _} -> current_depth + 1
+      {:try, _, _} -> current_depth + 1
+      {:with, _, _} -> current_depth + 1
+      {:for, _, _} -> current_depth + 1
+      {:__block__, _, statements} ->
+        Enum.map(statements, &calculate_nesting_recursive(&1, current_depth))
+        |> Enum.max(fn -> current_depth end)
+      {_, _, children} when is_list(children) ->
+        Enum.map(children, &calculate_nesting_recursive(&1, current_depth))
+        |> Enum.max(fn -> current_depth end)
+      _ -> current_depth
+    end
+  end
+
+  defp detect_loops_in_ast(ast) do
+    # Simplified loop detection
+    case ast do
+      {:for, _, _} -> true
+      {:while, _, _} -> true
+      {:__block__, _, statements} -> Enum.any?(statements, &detect_loops_in_ast/1)
+      {_, _, children} when is_list(children) -> Enum.any?(children, &detect_loops_in_ast/1)
+      _ -> false
+    end
+  end
+
+  defp detect_recursion_in_ast(ast) do
+    # Simplified recursion detection
+    # In practice, this would analyze function calls
+    false
+  end
+end

lib/elixir_scope/ast_repository/enhanced/project_populator/complexity_analyzer.ex

@@ -0,0 +1,65 @@
+defmodule ElixirScope.ASTRepository.Enhanced.ProjectPopulator.DependencyAnalyzer do
+  @moduledoc """
+  Analyzes dependencies between modules.
+
+  Provides functionality to:
+  - Build dependency graphs
+  - Detect dependency cycles
+  - Calculate dependency levels
+  - Analyze dependency patterns
+  """
+
+  require Logger
+
+  @doc """
+  Builds dependency graph from analyzed modules.
+  """
+  def build_dependency_graph(analyzed_modules, opts \\ []) do
+    track_dependencies = Keyword.get(opts, :track_dependencies, true)
+
+    if track_dependencies do
+      try do
+        dependency_graph = %{
+          nodes: Map.keys(analyzed_modules),
+          edges: extract_dependency_edges(analyzed_modules),
+          cycles: detect_dependency_cycles(analyzed_modules),
+          levels: calculate_dependency_levels(analyzed_modules)
+        }
+
+        {:ok, dependency_graph}
+      rescue
+        e ->
+          Logger.warning("Failed to build dependency graph: #{Exception.message(e)}")
+          {:ok, %{nodes: [], edges: [], cycles: [], levels: %{}}}
+      end
+    else
+      {:ok, %{nodes: [], edges: [], cycles: [], levels: %{}}}
+    end
+  end
+
+  # Private functions
+
+  defp extract_dependency_edges(analyzed_modules) do
+    # Extract module-to-module dependencies
+    Enum.flat_map(analyzed_modules, fn {module_name, module_data} ->
+      Enum.map(module_data.dependencies, fn dep ->
+        {module_name, dep}
+      end)
+    end)
+  end
+
+  defp detect_dependency_cycles(_analyzed_modules) do
+    # Simplified cycle detection
+    # In a real implementation, this would use graph algorithms
+    []
+  end
+
+  defp calculate_dependency_levels(analyzed_modules) do
+    # Calculate dependency levels for topological ordering
+    # Simplified implementation
+    analyzed_modules
+    |> Map.keys()
+    |> Enum.with_index()
+    |> Enum.into(%{}, fn {module, index} -> {module, index} end)
+  end
+end

lib/elixir_scope/ast_repository/enhanced/project_populator/dependency_analyzer.ex

@@ -0,0 +1,52 @@
+defmodule ElixirScope.ASTRepository.Enhanced.ProjectPopulator.FileDiscovery do
+  @moduledoc """
+  Handles discovery of Elixir files in a project directory.
+
+  Provides functionality to:
+  - Discover files based on include/exclude patterns
+  - Filter files by size limits
+  - Handle directory validation
+  """
+
+  require Logger
+
+  @doc """
+  Discovers all Elixir files in a project directory.
+  """
+  def discover_elixir_files(project_path, opts \\ []) do
+    include_patterns = Keyword.get(opts, :include_patterns, ["**/*.ex", "**/*.exs"])
+    exclude_patterns = Keyword.get(opts, :exclude_patterns, [])
+    max_file_size = Keyword.get(opts, :max_file_size, 1_000_000)
+
+    # Check if directory exists
+    if not (File.exists?(project_path) and File.dir?(project_path)) do
+      {:error, :directory_not_found}
+    else
+      try do
+        files = include_patterns
+        |> Enum.flat_map(fn pattern ->
+          Path.wildcard(Path.join(project_path, pattern))
+        end)
+        |> Enum.uniq()
+        |> Enum.reject(fn file ->
+          Enum.any?(exclude_patterns, fn pattern ->
+            String.contains?(file, pattern)
+          end)
+        end)
+        |> Enum.filter(fn file ->
+          case File.stat(file) do
+            {:ok, %{size: size}} when size <= max_file_size -> true
+            _ -> false
+          end
+        end)
+        |> Enum.sort()
+
+        Logger.debug("Discovered #{length(files)} Elixir files")
+        {:ok, files}
+      rescue
+        e ->
+          {:error, {:file_discovery_failed, Exception.message(e)}}
+      end
+    end
+  end
+end