From d03c79d6c7b22c9440e099fa3bef242e5ddd40f0 Mon Sep 17 00:00:00 2001 From: Mayel de Borniol Date: Fri, 14 Feb 2025 09:54:46 +0000 Subject: [PATCH] Update mixer.ex --- lib/mix/mixer.ex | 144 +++++++++++++++++++++++++++++++++++++---------- 1 file changed, 113 insertions(+), 31 deletions(-) diff --git a/lib/mix/mixer.ex b/lib/mix/mixer.ex index 922cc37..42e380e 100644 --- a/lib/mix/mixer.ex +++ b/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()