Update mixer.ex

lib/mix/mixer.ex

@@ -183,9 +183,10 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
            current_flavour,
            "1" = _WITH_ALL_FLAVOUR_DEPS
          ) do
-      enum_mess_sources(existing_sources)
       # ++ [disabled: other_flavour_sources(existing_sources, current_flavour)]
-      |> log("all_flavour_sources")
+      enum_mess_sources(existing_sources)
+
+      # |> log("all_flavour_sources")
     end
 
     defp maybe_all_flavour_sources(existing_sources, _flavour, _not_WITH_ALL_FLAVOUR_DEPS) do
@@ -262,7 +263,6 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
     def deps_to_update(config) do
       deps(config, :update)
       |> deps_names()
-
       # |> log(
       #   "Running Bonfire #{version(config)} at #{System.get_env("HOSTNAME", "localhost")} in #{Mix.env()} environment. You can run `just mix bonfire.deps.update` to update these extensions and dependencies"
       # )
@@ -395,11 +395,18 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
         |> String.replace("%{line}", "#{line}")
 
     # Specifies which paths to include when running tests
-    def test_paths(config),
-      do: [
+    def test_paths(config) do
+      testable_paths =
+        test_deps(config)
+        |> Enum.flat_map(&dep_paths(&1, "test"))
+
+      # |> IO.inspect(label: "testable_paths")
+
+      [
         "test"
-        | Enum.flat_map(test_deps(config), &dep_paths(&1, "test"))
+        | testable_paths
       ]
+    end
 
     def test_deps(config) do
       case System.get_env("MIX_TEST_ONLY") do
@@ -422,27 +429,109 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
         {_dep, opts} -> opts[:runtime] == false
         {_dep, _v, opts} -> opts[:runtime] == false
       end)
-      |> log("test_deps: #{System.get_env("MIX_TEST_ONLY")}")
+
+      # |> log("test_deps: #{System.get_env("MIX_TEST_ONLY")}")
     end
 
     # Specifies which paths to compile per environment
-    def elixirc_paths(config, :test),
-      do: [
-        # "lib",
+    def elixirc_paths(config, :test) do
+      paths_to_test = cli_args_paths_to_test()
+
+      testable_deps =
+        test_deps(config)
+        |> Enum.flat_map(&dep_paths/1)
+
+      testable_paths =
+        case find_matching_paths(paths_to_test, testable_deps) do
+          [] -> testable_deps
+          testable_paths -> testable_paths
+        end
+
+      [
+        "lib",
         "test/support"
-        | Enum.flat_map(
-            test_deps(config),
-            &dep_paths(&1, "test/support")
-          )
+        | dep_paths(testable_paths, "test/support")
+        # |> IO.inspect(label: "elixirc_paths")
+      ]
+    end
+
+    def elixirc_paths(_, env),
+      do:
+        [
+          "lib"
+        ] ++ catalogues(env)
+
+    def catalogues(_env) do
+      [
+        "deps/surface/priv/catalogue",
+        dep_path("bonfire_ui_common") <> "/priv/catalogue"
+      ]
+    end
+
+    def cli_args_paths_to_test do
+      # NOTE: must be kept up to date with @switches in https://github.com/elixir-lang/elixir/blob/main/lib/mix/lib/mix/tasks/test.ex
+      switches = [
+        all_warnings: :boolean,
+        breakpoints: :boolean,
+        force: :boolean,
+        color: :boolean,
+        cover: :boolean,
+        export_coverage: :string,
+        trace: :boolean,
+        max_cases: :integer,
+        max_failures: :integer,
+        include: :keep,
+        exclude: :keep,
+        seed: :integer,
+        only: :keep,
+        compile: :boolean,
+        start: :boolean,
+        timeout: :integer,
+        raise: :boolean,
+        deps_check: :boolean,
+        archives_check: :boolean,
+        elixir_version_check: :boolean,
+        failed: :boolean,
+        stale: :boolean,
+        listen_on_stdin: :boolean,
+        formatter: :keep,
+        slowest: :integer,
+        slowest_modules: :integer,
+        partitions: :integer,
+        preload_modules: :boolean,
+        warnings_as_errors: :boolean,
+        profile_require: :string,
+        exit_status: :integer,
+        repeat_until_failure: :integer
       ]
 
-    # ++ ["lib"]
-    def elixirc_paths(_, env), do: catalogues(env)
+      {_opts, wildcards_to_test, _} = System.argv() |> OptionParser.parse(strict: switches)
+
+      wildcards_to_test
+      |> Enum.map(&(&1 |> Path.expand() |> Path.wildcard() |> Path.relative_to_cwd()))
+
+      # |> IO.inspect(label: "paths_to_test")
+    end
+
+    def find_matching_paths(paths_to_test, testable_deps) do
+      testable_deps_set = MapSet.new(testable_deps)
+
+      Enum.flat_map(paths_to_test, fn filter_path ->
+        Enum.filter(testable_deps_set, fn dep_path ->
+          filter_path == dep_path or String.starts_with?(filter_path, dep_path) or
+            String.starts_with?(dep_path, filter_path)
+        end)
+      end)
+      |> Enum.uniq()
+      |> Enum.reject(&is_nil/1)
+    end
 
-    def include_dep?(type, dep, config_or_prefixes)
 
-    def include_dep?(:update, dep, _config_or_prefixes) when is_tuple(dep),
-      do: unpinned_git_dep?(dep)
+    def include_dep?(:update, dep, prefixes) when is_tuple(dep),
+      do: unpinned_git_dep?(dep) || String.starts_with?(
+        dep_name(dep),
+        prefixes
+      )
 
     # defp include_dep?(:docs = type, dep, deps_prefixes), do: String.starts_with?(dep_name(dep), deps_prefixes || @config[:deps_prefixes][type]) || git_dep?(dep)
     def include_dep?(_type, dep, prefixes) do
@@ -470,20 +559,20 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
 
     def dep_path(dep, force? \\ false)
 
-    def dep_path(dep, force?) when is_binary(dep) do
-      Enum.map(forks_paths(), &path_if_exists(&1 <> dep))
+    def dep_path(dep, force?) when is_binary(dep) or is_atom(dep) do
+      Enum.map(forks_paths() ++ [""], &path_if_exists("#{&1}#{dep}"))
       |> Enum.reject(&is_nil/1)
       |> List.first() ||
         (
           path =
-            (Mix.Project.deps_path() <> "/" <> dep)
+            (Mix.Project.deps_path() <> "/#{dep}")
             |> Path.expand(File.cwd!())
 
           if force?, do: path, else: path_if_exists(path) || "."
         )
     end
 
-    def dep_path(dep, force?) do
+    def dep_path(dep, force?) when is_tuple(dep) do
       spec = elem(dep, 1)
 
       path =
@@ -526,7 +615,7 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
     def version(config) do
       config[:version]
       |> String.split("-", parts: 2)
-      |> List.insert_at(1, flavour(config))
+      |> List.insert_at(1, flavour(config) |> String.replace("_", "-"))
       |> Enum.join("-")
     end
 
@@ -538,13 +627,6 @@ if not Code.ensure_loaded?(Bonfire.Mixer) do
       Mix.compilers() ++ [:surface]
     end
 
-    def catalogues(_env) do
-      [
-        "deps/surface/priv/catalogue",
-        dep_path("bonfire_ui_common") <> "/priv/catalogue"
-      ]
-    end
-
     def deps_tree do
       if function_exported?(Mix.Project, :deps_tree, 0) do
         Mix.Project.deps_tree()