update test apps

Author: NSHkr

test_apps/elixir_analyzer_demo/lib/elixir_analyzer_demo.ex

@@ -26,7 +26,7 @@ defmodule ElixirAnalyzerDemo do
   """
 
   alias ElixirScope.ASTRepository.{EnhancedRepository, MemoryManager}
-  alias ElixirAnalyzerDemo.{AnalysisEngine, SampleDataManager, PerformanceMonitor}
+  alias ElixirAnalyzerDemo.{SampleDataManager, PerformanceMonitor}
 
   @doc """
   Loads sample projects for analysis and demonstration.
@@ -280,6 +280,64 @@ defmodule ElixirAnalyzerDemo do
     end)
   end
 
+  defp create_complex_ast(module_name), do: create_complex_ast(module_name, [])
+  defp create_complex_ast(module_name, opts) do
+    complexity = Keyword.get(opts, :complexity, :medium)
+    
+    case complexity do
+      :high ->
+        quote do
+          defmodule unquote(module_name) do
+            def complex_logic(data) do
+              case data do
+                %{type: :process, items: items} when is_list(items) ->
+                  items
+                  |> Enum.filter(&valid_item?/1)
+                  |> Enum.group_by(&get_category/1)
+                  |> Enum.map(fn {category, items} ->
+                    {category, process_category(category, items)}
+                  end)
+                  |> Enum.into(%{})
+                
+                %{type: :aggregate, data: data} ->
+                  aggregate_data(data)
+                
+                _ ->
+                  {:error, :invalid_data}
+              end
+            end
+            
+            defp valid_item?(%{id: id, value: value}) when is_integer(id) and is_number(value) do
+              value > 0
+            end
+            defp valid_item?(_), do: false
+            
+            defp get_category(%{category: cat}), do: cat
+            defp get_category(_), do: :unknown
+            
+            defp process_category(:important, items) do
+              items |> Enum.map(&enhance_item/1) |> Enum.sort_by(& &1.priority, :desc)
+            end
+            defp process_category(_, items), do: items
+            
+            defp enhance_item(item), do: Map.put(item, :priority, calculate_priority(item))
+            defp calculate_priority(%{value: value}), do: value * 1.5
+            
+            defp aggregate_data(data) when is_list(data) do
+              %{
+                count: length(data),
+                sum: Enum.sum(data),
+                average: Enum.sum(data) / length(data)
+              }
+            end
+          end
+        end
+      
+      _ ->
+        create_sample_ast(module_name)
+    end
+  end
+
   defp benchmark_operations do
     # Module lookup benchmark
     {time_us, _result} = :timer.tc(fn ->
@@ -351,63 +409,6 @@ defmodule ElixirAnalyzerDemo do
     end
   end
 
-  defp create_complex_ast(module_name, opts \\ []) do
-    complexity = Keyword.get(opts, :complexity, :medium)
-    
-    case complexity do
-      :high ->
-        quote do
-          defmodule unquote(module_name) do
-            def complex_logic(data) do
-              case data do
-                %{type: :process, items: items} when is_list(items) ->
-                  items
-                  |> Enum.filter(&valid_item?/1)
-                  |> Enum.group_by(&get_category/1)
-                  |> Enum.map(fn {category, items} ->
-                    {category, process_category(category, items)}
-                  end)
-                  |> Enum.into(%{})
-                
-                %{type: :aggregate, data: data} ->
-                  aggregate_data(data)
-                
-                _ ->
-                  {:error, :invalid_data}
-              end
-            end
-            
-            defp valid_item?(%{id: id, value: value}) when is_integer(id) and is_number(value) do
-              value > 0
-            end
-            defp valid_item?(_), do: false
-            
-            defp get_category(%{category: cat}), do: cat
-            defp get_category(_), do: :unknown
-            
-            defp process_category(:important, items) do
-              items |> Enum.map(&enhance_item/1) |> Enum.sort_by(& &1.priority, :desc)
-            end
-            defp process_category(_, items), do: items
-            
-            defp enhance_item(item), do: Map.put(item, :priority, calculate_priority(item))
-            defp calculate_priority(%{value: value}), do: value * 1.5
-            
-            defp aggregate_data(data) when is_list(data) do
-              %{
-                count: length(data),
-                sum: Enum.sum(data),
-                average: Enum.sum(data) / length(data)
-              }
-            end
-          end
-        end
-      
-      _ ->
-        create_sample_ast(module_name)
-    end
-  end
-
   defp format_bytes(bytes) when bytes < 1024, do: "#{bytes} B"
   defp format_bytes(bytes) when bytes < 1024 * 1024, do: "#{Float.round(bytes / 1024, 1)} KB"
   defp format_bytes(bytes) when bytes < 1024 * 1024 * 1024, do: "#{Float.round(bytes / (1024 * 1024), 1)} MB"

test_apps/elixir_analyzer_demo/lib/elixir_analyzer_demo/analysis_engine.ex

@@ -13,7 +13,7 @@ defmodule ElixirAnalyzerDemo.AnalysisEngine do
 
   use GenServer
 
-  alias ElixirScope.ASTRepository.{EnhancedRepository, MemoryManager}
+  alias ElixirScope.ASTRepository.EnhancedRepository
 
   def start_link(opts) do
     GenServer.start_link(__MODULE__, opts, name: __MODULE__)
@@ -392,7 +392,7 @@ defmodule ElixirAnalyzerDemo.AnalysisEngine do
   defp check_inefficient_patterns(ast, bottlenecks) do
     {_, new_bottlenecks} = Macro.prewalk(ast, bottlenecks, fn
       # Check for inefficient list operations
-      {{:., _, [{:__aliases__, _, [:Enum]}, :map]}, _, [list, {{:., _, [{:__aliases__, _, [:Enum]}, :filter]}, _, _}]}, acc ->
+      {{:., _, [{:__aliases__, _, [:Enum]}, :map]}, _, [_list, {{:., _, [{:__aliases__, _, [:Enum]}, :filter]}, _, _}]}, acc ->
         bottleneck = %{
           type: :inefficient_enum_chain,
           severity: :medium,
@@ -498,7 +498,7 @@ defmodule ElixirAnalyzerDemo.AnalysisEngine do
   # Utility functions
 
   defp update_analysis_results(module_name, analysis_result) do
-    EnhancedRepository.update_enhanced_module(module_name, [
+    EnhancedRepository.store_enhanced_module(module_name, [
       metadata: %{
         complexity_score: analysis_result.complexity.score,
         dependency_count: analysis_result.dependencies.total_dependencies,
@@ -563,8 +563,27 @@ defmodule ElixirAnalyzerDemo.AnalysisEngine do
 
   defp count_patterns(_head), do: 1
   defp has_guards_or_pattern_matching?(_params), do: false
-  defp has_interpolation?(_parts), do: false
-  defp looks_like_sql?(_parts), do: false
+  
+  defp has_interpolation?(parts) when is_list(parts) do
+    Enum.any?(parts, fn
+      {:"::", _, [expr, _type]} -> not is_binary(expr)
+      binary when is_binary(binary) -> false
+      _ -> true
+    end)
+  end
+  defp has_interpolation?(_), do: false
+
+  defp looks_like_sql?(parts) when is_list(parts) do
+    sql_keywords = ~w(SELECT INSERT UPDATE DELETE FROM WHERE JOIN)
+    parts_string = Enum.map_join(parts, "", fn
+      binary when is_binary(binary) -> binary
+      _ -> ""
+    end)
+    String.upcase(parts_string)
+    |> then(&Enum.any?(sql_keywords, fn kw -> String.contains?(&1, kw) end))
+  end
+  defp looks_like_sql?(_), do: false
+  
   defp count_by_severity(issues), do: Enum.group_by(issues, & &1.severity) |> Enum.map(fn {k, v} -> {k, length(v)} end) |> Enum.into(%{})
   defp calculate_risk_score(issues), do: length(issues) * 10
   defp estimate_performance_score(_bottlenecks), do: 75.0

test_apps/elixir_analyzer_demo/lib/elixir_analyzer_demo/application.ex

@@ -60,13 +60,15 @@ defmodule ElixirAnalyzerDemo.Application do
     Supervisor.start_link(children, opts)
   end
 
-  # Tell Phoenix to update the endpoint configuration
-  # whenever the application is updated.
+  def stop(_state) do
+    :ok
+  end
+
+  # Optional callbacks
+
   @impl true
   def config_change(changed, _new, removed) do
-    if phoenix_enabled?() do
-      ElixirAnalyzerDemo.Endpoint.config_change(changed, removed)
-    end
+    # Remove the endpoint config_change call since we don't have an Endpoint module
     :ok
   end