a3fb310680b32807957a42335caaaea14df2cc5d

Committed 29 May 2025 04:40AM UTC coverage: 58.763% (-0.1%) from 58.866%

Build # a3fb310680b32807957a42335caaaea14df2cc5d

Build Type

push

github

Committed by NSHkr

Commit Message

refactor pattern matcher

Run Details

77 of 218 new or added lines in 10 files covered. (35.32%)

18 existing lines in 2 files now uncovered.

5918 of 10071 relevant lines covered (58.76%)

3267.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.43

/lib/elixir_scope/ast_repository/pattern_matcher/validators.ex

defmodule ElixirScope.ASTRepository.PatternMatcher.Validators do
  @moduledoc """
  Validation functions for pattern matching operations.
  """

  alias ElixirScope.ASTRepository.PatternMatcher.Types

  @spec normalize_pattern_spec(map()) :: {:ok, Types.pattern_spec()} | {:error, term()}
  def normalize_pattern_spec(pattern_spec) when is_map(pattern_spec) do
    confidence = Map.get(pattern_spec, :confidence_threshold, Types.default_confidence_threshold())

    with :ok <- validate_confidence_threshold(confidence) do
      spec = %Types{
        pattern_type: Map.get(pattern_spec, :pattern_type),
        pattern_ast: Map.get(pattern_spec, :pattern),
        confidence_threshold: confidence,
        match_variables: Map.get(pattern_spec, :match_variables, true),
        context_sensitive: Map.get(pattern_spec, :context_sensitive, false),
        custom_rules: Map.get(pattern_spec, :custom_rules),
        metadata: Map.get(pattern_spec, :metadata, %{})
      }

      case validate_pattern_spec(spec) do
        :ok -> {:ok, spec}
        error -> error
      end
    end
  end

  def normalize_pattern_spec(_), do: {:error, :invalid_pattern_spec}

  @spec validate_repository(pid() | atom()) :: :ok | {:error, term()}
  def validate_repository(repo) do
    cond do
      is_nil(repo) ->
        {:error, :invalid_repository}

      is_atom(repo) and repo in [:mock_repo, :non_existent_repo] ->
        {:error, :repository_not_found}

      is_atom(repo) ->
        case Process.whereis(repo) do
          nil -> {:error, :repository_not_found}
          _pid -> :ok
        end

      is_pid(repo) ->
        if Process.alive?(repo) do
          :ok
        else
          {:error, :repository_not_found}
        end

      true ->
        {:error, :invalid_repository}
    end
  end

  # Private functions

  defp validate_confidence_threshold(confidence) do
    cond do
      not is_number(confidence) ->
        {:error, :invalid_confidence_threshold}

      confidence < 0.0 or confidence > 1.0 ->
        {:error, :invalid_confidence_threshold}

      true ->
        :ok
    end
  end

  defp validate_pattern_spec(%Types{pattern_ast: pattern, pattern_type: pattern_type}) when not is_nil(pattern) do
    cond do
      is_nil(pattern_type) -> {:error, :missing_pattern_type}
      pattern == nil -> {:error, :invalid_ast_pattern}
      is_binary(pattern) -> {:error, :invalid_ast_pattern}
      true -> :ok
    end
  end

  defp validate_pattern_spec(%Types{pattern_type: nil}) do
    {:error, :missing_pattern_type}
  end

  defp validate_pattern_spec(%Types{}), do: :ok
end

1	defmodule ElixirScope.ASTRepository.PatternMatcher.Validators do
2	@moduledoc """
3	Validation functions for pattern matching operations.
4	"""
5
6	alias ElixirScope.ASTRepository.PatternMatcher.Types
7
8	@spec normalize_pattern_spec(map()) :: {:ok, Types.pattern_spec()} \| {:error, term()}
9	def normalize_pattern_spec(pattern_spec) when is_map(pattern_spec) do
10	confidence = Map.get(pattern_spec, :confidence_threshold, Types.default_confidence_threshold())	52✔
11
12	with :ok <- validate_confidence_threshold(confidence) do	52✔
13	spec = %Types{	48✔
14	pattern_type: Map.get(pattern_spec, :pattern_type),
15	pattern_ast: Map.get(pattern_spec, :pattern),
16	confidence_threshold: confidence,
17	match_variables: Map.get(pattern_spec, :match_variables, true),
18	context_sensitive: Map.get(pattern_spec, :context_sensitive, false),
19	custom_rules: Map.get(pattern_spec, :custom_rules),
20	metadata: Map.get(pattern_spec, :metadata, %{})
21	}
22
23	case validate_pattern_spec(spec) do	48✔
24	:ok -> {:ok, spec}	34✔
25	error -> error	14✔
26	end
27	end
28	end
29
30	def normalize_pattern_spec(_), do: {:error, :invalid_pattern_spec}	3✔
31
32	@spec validate_repository(pid() \| atom()) :: :ok \| {:error, term()}
33	def validate_repository(repo) do
34	cond do	29✔
35	is_nil(repo) ->	2✔
36	{:error, :invalid_repository}
37
38	is_atom(repo) and repo in [:mock_repo, :non_existent_repo] ->	27✔
39	{:error, :repository_not_found}
40
41	is_atom(repo) ->	1✔
42	case Process.whereis(repo) do	1✔
43	nil -> {:error, :repository_not_found}	1✔
NEW 44	_pid -> :ok	×
45	end
46
NEW 47	is_pid(repo) ->	×
NEW 48	if Process.alive?(repo) do	×
49	:ok
50	else
51	{:error, :repository_not_found}
52	end
53
NEW 54	true ->	×
55	{:error, :invalid_repository}
56	end
57	end
58
59	# Private functions
60
61	defp validate_confidence_threshold(confidence) do
62	cond do	52✔
NEW 63	not is_number(confidence) ->	×
64	{:error, :invalid_confidence_threshold}
65
66	confidence < 0.0 or confidence > 1.0 ->	52✔
67	{:error, :invalid_confidence_threshold}
68
69	true ->	48✔
70	:ok
71	end
72	end
73
74	defp validate_pattern_spec(%Types{pattern_ast: pattern, pattern_type: pattern_type}) when not is_nil(pattern) do
75	cond do	12✔
76	is_nil(pattern_type) -> {:error, :missing_pattern_type}	12✔
NEW 77	pattern == nil -> {:error, :invalid_ast_pattern}	×
NEW 78	is_binary(pattern) -> {:error, :invalid_ast_pattern}	×
NEW 79	true -> :ok	×
80	end
81	end
82
83	defp validate_pattern_spec(%Types{pattern_type: nil}) do	2✔
84	{:error, :missing_pattern_type}
85	end
86
87	defp validate_pattern_spec(%Types{}), do: :ok	34✔
88	end

nshkrdotcom / ElixirScope / a3fb310680b32807957a42335caaaea14df2cc5d

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous