Analyze bird-count

config/config.exs

@@ -31,6 +31,9 @@ config :elixir_analyzer,
     },
     "take-a-number" => %{
       analyzer_module: ElixirAnalyzer.TestSuite.TakeANumber
+    },
+    "bird-count" => %{
+      analyzer_module: ElixirAnalyzer.TestSuite.BirdCount
     }
   }
 

lib/elixir_analyzer/constants.ex

@@ -38,7 +38,10 @@ defmodule ElixirAnalyzer.Constants do
       "elixir.pacman-rules.use_strictly_boolean_operators",
 
     # Take A Number Comments
-    take_a_number_do_not_use_abstractions: "elixir.take-a-number.do_not_use_abstractions"
+    take_a_number_do_not_use_abstractions: "elixir.take-a-number.do_not_use_abstractions",
+
+    # Bird Count Comments
+    bird_count_use_recursion: "elixir.bird-count.use_recursion"
   ]
 
   for {constant, markdown} <- @constants do

lib/elixir_analyzer/exercise_test.ex

@@ -24,7 +24,7 @@ defmodule ElixirAnalyzer.ExerciseTest do
 
   defmacro __before_compile__(env) do
     # credo:disable-for-previous-line Credo.Check.Refactor.CyclomaticComplexity
-    feature_test_data = Macro.escape(Module.get_attribute(env.module, :feature_tests))
+    feature_test_data = Module.get_attribute(env.module, :feature_tests)
     assert_call_data = Module.get_attribute(env.module, :assert_call_tests)
 
     # ast placeholder for the submission code ast

lib/elixir_analyzer/exercise_test/assert_call.ex

@@ -68,8 +68,7 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCall do
     {node, Map.put(test_data, :called_fn, formatted_signature)}
   end
 
-  defp do_walk_assert_call_block({:comment, _, [comment]} = node, test_data)
-       when is_binary(comment) do
+  defp do_walk_assert_call_block({:comment, _, [comment]} = node, test_data) do
     {node, Map.put(test_data, :comment, comment)}
   end
 
@@ -117,9 +116,11 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCall do
         {:__aliases__, _, module} ->
           module
 
-        _ ->
+        x ->
           raise ArgumentError,
-                "calling function signature requires :module to be nil or a module atom"
+                "calling function signature requires :module to be nil or a module atom, got: #{
+                  inspect(x)
+                }"
       end
 
     Keyword.put(signature, :module, module)
@@ -128,8 +129,12 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCall do
   defp validate_name(signature) do
     module =
       case signature[:name] do
-        name when is_atom(name) -> name
-        _ -> raise ArgumentError, "calling function signature requires :name to be an atom"
+        name when is_atom(name) ->
+          name
+
+        x ->
+          raise ArgumentError,
+                "calling function signature requires :name to be an atom, got: #{inspect(x)}"
       end
 
     Keyword.put(signature, :name, module)

lib/elixir_analyzer/exercise_test/assert_call/compiler.ex

@@ -12,7 +12,7 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCall.Compiler do
     name = assert_call_data.description
     called_fn = Macro.escape(assert_call_data.called_fn)
     calling_fn = Macro.escape(assert_call_data.calling_fn)
-    comment = assert_call_data.comment
+    {comment, _} = Code.eval_quoted(assert_call_data.comment)
     should_call = assert_call_data.should_call
     type = assert_call_data.type
 
@@ -145,7 +145,7 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCall.Compiler do
 
   def matching_function_call?(
         {name, _, _args},
-        {_, name}
+        {nil, name}
       ) do
     true
   end

lib/elixir_analyzer/exercise_test/feature/compiler.ex

@@ -5,7 +5,7 @@ defmodule ElixirAnalyzer.ExerciseTest.Feature.Compiler do
 
   def compile({feature_data, feature_forms}, code_ast) do
     name = Keyword.fetch!(feature_data, :name)
-    comment = Keyword.fetch!(feature_data, :comment)
+    {comment, _} = Code.eval_quoted(Keyword.fetch!(feature_data, :comment))
     status = Keyword.get(feature_data, :status, :test)
     type = Keyword.get(feature_data, :type, :informative)
     find_type = Keyword.get(feature_data, :find, :all)

lib/elixir_analyzer/test_suite/bird_count.ex

@@ -0,0 +1,104 @@
+defmodule ElixirAnalyzer.TestSuite.BirdCount do
+  @dialyzer generated: true
+  @moduledoc """
+  This is an exercise analyzer extension module for the concept exercise Bird Count
+  """
+
+  use ElixirAnalyzer.ExerciseTest
+
+  assert_no_call "does not call any Enum functions" do
+    type :essential
+    called_fn module: Enum, name: :_
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+  end
+
+  feature "does not alias or import Enum" do
+    find :none
+    type :essential
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+
+    form do
+      import Enum
+    end
+
+    form do
+      import Enum, _ignore
+    end
+
+    form do
+      alias Enum, as: _ignore
+    end
+  end
+
+  assert_no_call "does not call any Stream functions" do
+    type :essential
+    called_fn module: Stream, name: :_
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+  end
+
+  feature "does not alias or import Stream" do
+    find :none
+    type :essential
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+
+    form do
+      import Stream
+    end
+
+    form do
+      import Stream, _ignore
+    end
+
+    form do
+      alias Stream, as: _ignore
+    end
+  end
+
+  assert_no_call "does not call any List functions" do
+    type :essential
+    called_fn module: List, name: :_
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+  end
+
+  feature "does not alias or import List" do
+    find :none
+    type :essential
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+
+    form do
+      import List
+    end
+
+    form do
+      import List, _ignore
+    end
+
+    form do
+      alias List, as: _ignore
+    end
+  end
+
+  feature "doesn't use list comprehensions" do
+    find :none
+    type :essential
+    comment ElixirAnalyzer.Constants.bird_count_use_recursion()
+
+    form do
+      for _ignore <- _ignore do
+        _ignore
+      end
+    end
+
+    form do
+      for _ignore <- _ignore, _ignore do
+        _ignore
+      end
+    end
+
+    form do
+      for _ignore <- _ignore, _ignore, into: _ignore do
+        _ignore
+      end
+    end
+  end
+end

test/elixir_analyzer/exercise_test/assert_call_test.exs

@@ -120,7 +120,8 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCallTest do
 
   test_exercise_analysis "missing call to a List function in function/0 solution",
     comments: [
-      "didn't find a call to a List function in function/0"
+      "didn't find a call to a List function in function/0",
+      "mock.constant"
     ] do
     defmodule AssertCallVerification do
       def function() do
@@ -144,7 +145,8 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCallTest do
   test_exercise_analysis "missing call to a List function in solution",
     comments: [
       "didn't find a call to a List function",
-      "didn't find a call to a List function in function/0"
+      "didn't find a call to a List function in function/0",
+      "mock.constant"
     ] do
     defmodule AssertCallVerification do
       def function() do
@@ -163,4 +165,30 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertCallTest do
       end
     end
   end
+
+  test_exercise_analysis "usages of the underscore don't fool the missing call check",
+    comments: [
+      "didn't find a call to a List function",
+      "didn't find a call to a List function in function/0",
+      "mock.constant"
+    ] do
+    defmodule AssertCallVerification do
+      def function() do
+        result = helper()
+        IO.puts(result)
+
+        2 * 3
+
+        _ = private_helper() |> IO.puts()
+      end
+
+      def helper do
+        :helped
+      end
+
+      defp private_helper do
+        :privately_helped
+      end
+    end
+  end
 end

test/elixir_analyzer/exercise_test/assert_no_call_test.exs

@@ -78,6 +78,40 @@ defmodule ElixirAnalyzer.ExerciseTest.AssertNoCallTest do
     end
   end
 
+  test_exercise_analysis "calling a function with the same name or imported doesn't trigger the check",
+    comments: [] do
+    [
+      defmodule AssertNoCallVerification do
+        def function() do
+          map([], fn x -> x + 1 end)
+        end
+
+        def helper do
+          :helped
+        end
+
+        defp private_helper do
+          :privately_helped
+        end
+      end,
+      defmodule AssertNoCallVerification do
+        import Enum
+
+        def function() do
+          map([], fn x -> x + 1 end)
+        end
+
+        def helper do
+          :helped
+        end
+
+        defp private_helper do
+          :privately_helped
+        end
+      end
+    ]
+  end
+
   test_exercise_analysis "found a call to other module function in specific function",
     comments: [
       "found a call to Atom.to_string/1 in helper/0 function in solution"