From 0c4704a1ba6a3ca22c96376701906fcec6733a33 Mon Sep 17 00:00:00 2001 From: Christian Koch Date: Mon, 20 Sep 2021 11:29:38 -0500 Subject: [PATCH] Add changer module to change function refs. --- lib/ex_factor.ex | 3 + lib/ex_factor/changer.ex | 139 +++++++++++++++++++ lib/ex_factor/util.ex | 9 ++ test/ex_factor/changer_test.exs | 234 ++++++++++++++++++++++++++++++++ test/ex_factor/util_test.exs | 19 +++ 5 files changed, 404 insertions(+) create mode 100644 lib/ex_factor/changer.ex create mode 100644 lib/ex_factor/util.ex create mode 100644 test/ex_factor/changer_test.exs create mode 100644 test/ex_factor/util_test.exs diff --git a/lib/ex_factor.ex b/lib/ex_factor.ex index be5144f..269ca4a 100644 --- a/lib/ex_factor.ex +++ b/lib/ex_factor.ex @@ -9,6 +9,7 @@ defmodule ExFactor do new module's name. """ + alias ExFactor.Changer alias ExFactor.Extractor alias ExFactor.Remover @@ -26,6 +27,8 @@ defmodule ExFactor do emplace = Extractor.emplace(opts) remove = Remover.remove(opts) + _changes = Changer.change(opts) + |> IO.inspect(label: "") {emplace, remove} end diff --git a/lib/ex_factor/changer.ex b/lib/ex_factor/changer.ex new file mode 100644 index 0000000..b4bdf01 --- /dev/null +++ b/lib/ex_factor/changer.ex @@ -0,0 +1,139 @@ +defmodule ExFactor.Changer do + @moduledoc """ + Documentation for `ExFactor.Changer`. + """ + + alias ExFactor.Callers + alias ExFactor.Util + + @doc """ + Given all the Callers to a module, find the instances of the target function and refactor the + function module reference to the new module. Respect any existing aliases. + """ + def change(opts) do + source_module = Keyword.fetch!(opts, :source_module) + Mix.Tasks.Compile.Elixir.run([]) + callers = Callers.callers(source_module) + + Enum.map(callers, fn caller -> + File.read!(caller.filepath) + |> String.split("\n") + |> find_and_replace_target(opts, caller.filepath) + end) + end + + defp find_and_replace_target(list, opts, filepath) do + # opts values + source_module = Keyword.fetch!(opts, :source_module) + source_function = Keyword.fetch!(opts, :source_function) + target_module = Keyword.fetch!(opts, :target_module) + _arity = Keyword.fetch!(opts, :arity) + dry_run = Keyword.get(opts, :dry_run, false) + + # modified values + source_string = Util.module_to_string(source_module) + source_modules = Module.split(source_module) + source_alias = Enum.at(source_modules, -1) + target_alias = preferred_alias(list, target_module) + source_alias_alt = find_alias_as(list, source_module) + + Enum.reduce(list, {:unchanged, []}, fn elem, {state, acc} -> + cond do + String.match?(elem, ~r/#{source_string}\.#{source_function}/) -> + elem = String.replace(elem, source_module, target_module) + {:changed, [elem | acc]} + String.match?(elem, ~r/#{source_alias}\.#{source_function}/) -> + elem = String.replace(elem, source_alias, target_alias) + {:changed, [elem | acc]} + String.match?(elem, ~r/#{source_alias_alt}\.#{source_function}/) -> + elem = String.replace(elem, source_alias_alt, target_alias) + {:changed, [elem | acc]} + true -> {state, [elem | acc]} + end + end) + |> maybe_add_alias(opts) + |> write_file(source_function, filepath, dry_run) + end + + defp find_alias_as(list, module) do + aalias = Enum.find(list, "", fn el -> el =~ "alias #{Util.module_to_string(module)}" end) + if String.match?(aalias, ~r/, as: /) do + aalias + |> String.split("as:", trim: true) + |> Enum.at(-1) + else + "" + end + end + + defp preferred_alias(list, target_module) do + target_modules = Module.split(target_module) + target_alias = Enum.at(target_modules, -1) + target_alias_alt = find_alias_as(list, target_module) + + if target_alias_alt == "" do + target_alias + else + target_alias_alt + end + end + + defp write_file({:unchanged, contents_list}, source_function, target_path, true) do + %{ + path: target_path, + state: [:unchanged], + message: "#{source_function} not found, no changes to make", + file_contents: list_to_string(contents_list) + } + end + + defp write_file({state, contents_list}, _, target_path, true) do + %{ + path: target_path, + state: [:dry_run, state], + message: "--dry_run changes to make", + file_contents: list_to_string(contents_list) + } + end + + defp write_file({state, contents_list}, _, target_path, _dry_run) do + contents = list_to_string(contents_list) + File.write(target_path, contents, [:write]) + %{ + path: target_path, + state: [state], + message: "changes made", + file_contents: contents + } + end + + defp list_to_string(contents_list) do + contents_list + |> Enum.reverse() + |> Enum.join("\n") + end + + defp maybe_add_alias({:unchanged, contents_list}, _), do: {:unchanged, contents_list} + defp maybe_add_alias({state, contents_list}, opts) do + source_module = Keyword.fetch!(opts, :source_module) + source_string = Util.module_to_string(source_module) + target_module = Keyword.fetch!(opts, :target_module) + target_string = Util.module_to_string(target_module) + + if Enum.find(contents_list, fn el -> el =~ "alias #{target_string}" end) do + {state, contents_list} + else + contents_list + |> Enum.reduce([], fn elem, acc -> + if (elem =~ "alias #{source_string}") do + new_alias = String.replace(elem, source_string, target_string) + [new_alias | [elem | acc]] + else + [elem | acc] + end + end) + |> Enum.reverse() + |> then(fn list -> {state, list} end) + end + end +end diff --git a/lib/ex_factor/util.ex b/lib/ex_factor/util.ex new file mode 100644 index 0000000..aca3aff --- /dev/null +++ b/lib/ex_factor/util.ex @@ -0,0 +1,9 @@ +defmodule ExFactor.Util do + @moduledoc false + + def module_to_string(module) do + module + |> Module.split() + |> Enum.join(".") + end +end diff --git a/test/ex_factor/changer_test.exs b/test/ex_factor/changer_test.exs new file mode 100644 index 0000000..4a3da22 --- /dev/null +++ b/test/ex_factor/changer_test.exs @@ -0,0 +1,234 @@ +defmodule ExFactor.ChangerTest do + use ExUnit.Case + alias ExFactor.Changer + + setup_all do + File.mkdir_p("lib/ex_factor/tmp") + + on_exit(fn -> + File.rm_rf("lib/ex_factor/tmp") + end) + end + + describe "change/1" do + test "it finds all the callers of a module, function, and arity, and updates the calls to the new module " do + content = """ + defmodule ExFactor.Tmp.SourceMod do + @moduledoc "This is moduedoc" + @doc "this is some documentation for refactor1/1" + def refactor1([]) do + :empty + end + def refactor1(arg1) do + {:ok, arg1} + end + end + """ + + File.write("lib/ex_factor/tmp/source_module.ex", content) + + content = """ + defmodule ExFactor.Tmp.CallerModule do + alias ExFactor.Tmp.SourceMod + def pub1(arg_a) do + SourceMod.refactor1(arg_a) + end + end + """ + + File.write("lib/ex_factor/tmp/caller_module.ex", content) + + opts = [ + target_module: ExFactor.Tmp.TargetModule, + source_module: ExFactor.Tmp.SourceMod, + source_function: :refactor1, + arity: 1 + ] + + Changer.change(opts) + + caller = File.read!("lib/ex_factor/tmp/caller_module.ex") + assert caller =~ "alias ExFactor.Tmp.TargetModule" + assert caller =~ "TargetModule.refactor1(arg_a)" + end + + test "only add alias entry if it's missing" do + content = """ + defmodule ExFactor.Tmp.SourceMod do + @moduledoc "This is moduedoc" + @doc "this is some documentation for refactor1/1" + def refactor1([]) do + :empty + end + def refactor1(arg1) do + {:ok, arg1} + end + end + """ + + File.write("lib/ex_factor/tmp/source_module.ex", content) + + content = """ + defmodule ExFactor.Tmp.CallerModule do + alias ExFactor.Tmp.SourceMod + alias ExFactor.Tmp.TargetModule + def pub1(arg_a) do + SourceMod.refactor1(arg_a) + end + def alias2, do: TargetModule + end + """ + + File.write("lib/ex_factor/tmp/caller_module.ex", content) + + opts = [ + target_module: ExFactor.Tmp.TargetModule, + source_module: ExFactor.Tmp.SourceMod, + source_function: :refactor1, + arity: 1 + ] + + Changer.change(opts) + + caller = File.read!("lib/ex_factor/tmp/caller_module.ex") + + caller_list = String.split(caller, "\n") + assert caller =~ "alias ExFactor.Tmp.TargetModule" + assert caller =~ "TargetModule.refactor1(arg_a)" + assert 1 == Enum.count(caller_list, fn el -> + el =~ "alias ExFactor.Tmp.TargetModule" + end) + end + + test "handle alias exists with :as" do + content = """ + defmodule ExFactor.Tmp.SourceMod do + @moduledoc "This is moduedoc" + @doc "this is some documentation for refactor1/1" + def refactor1([]) do + :empty + end + def refactor1(arg1) do + {:ok, arg1} + end + end + """ + + File.write("lib/ex_factor/tmp/source_module.ex", content) + + content = """ + defmodule ExFactor.Tmp.CallerModule do + alias ExFactor.Tmp.SourceMod + alias ExFactor.Tmp.TargetModule, as: TM + def pub1(arg_a) do + SourceMod.refactor1(arg_a) + end + def alias2, do: TM + end + """ + + File.write("lib/ex_factor/tmp/caller_module.ex", content) + + opts = [ + target_module: ExFactor.Tmp.TargetModule, + source_module: ExFactor.Tmp.SourceMod, + source_function: :refactor1, + arity: 1 + ] + + Changer.change(opts) + + caller = File.read!("lib/ex_factor/tmp/caller_module.ex") + + caller_list = String.split(caller, "\n") + assert caller =~ "alias ExFactor.Tmp.TargetModule" + assert caller =~ "TM.refactor1(arg_a)" + assert 1 == Enum.count(caller_list, fn el -> + el =~ "alias ExFactor.Tmp.TargetModule" + end) + end + + test "it finds all the callers of a module by an alias, function, and arity, and updates the calls to the new module " do + content = """ + defmodule ExFactor.Tmp.SourceMod do + def refactor1(_arg1, _opt2 \\\\ []) do + :ok + end + end + """ + + File.write("lib/ex_factor/tmp/source_module.ex", content) + + content = """ + defmodule ExFactor.Tmp.CallerModule do + alias ExFactor.Tmp.SourceMod, as: SM + def pub1(arg_a) do + SM.refactor1(arg_a) + end + end + """ + + File.write("lib/ex_factor/tmp/caller_module.ex", content) + + opts = [ + target_module: ExFactor.Tmp.TargetModule, + source_module: ExFactor.Tmp.SourceMod, + source_function: :refactor1, + arity: 1 + ] + + Changer.change(opts) + + caller = File.read!("lib/ex_factor/tmp/caller_module.ex") + assert caller =~ "alias ExFactor.Tmp.TargetModule" + assert caller =~ "TargetModule.refactor1(arg_a)" + end + + test "matches the arity" do + end + + test "changes multiple functions" do + end + + test "takes a dry_run argument and doesn't update the files" do + content = """ + defmodule ExFactor.Tmp.SourceMod do + def refactor1(_arg1, _opt2 \\\\ []) do + :ok + end + end + """ + + File.write("lib/ex_factor/tmp/source_module.ex", content) + + content = """ + defmodule ExFactor.Tmp.CallerModule do + alias ExFactor.Tmp.SourceMod, as: SM + def pub1(arg_a) do + SM.refactor1(arg_a) + end + end + """ + + File.write("lib/ex_factor/tmp/caller_module.ex", content) + + opts = [ + target_module: ExFactor.Tmp.TargetModule, + source_module: ExFactor.Tmp.SourceMod, + source_function: :refactor1, + dry_run: true, + arity: 1 + ] + + [change_map] = Changer.change(opts) + # |> IO.inspect(label: "") + + caller = File.read!("lib/ex_factor/tmp/caller_module.ex") + + refute caller =~ "alias ExFactor.Tmp.TargetModule" + refute caller =~ "TargetModule.refactor1(arg_a)" + assert change_map.state == [:dry_run, :changed] + assert change_map.message == "--dry_run changes to make" + end + end +end diff --git a/test/ex_factor/util_test.exs b/test/ex_factor/util_test.exs new file mode 100644 index 0000000..caebdf9 --- /dev/null +++ b/test/ex_factor/util_test.exs @@ -0,0 +1,19 @@ +defmodule ExFactor.UtilTest do + use ExUnit.Case + alias ExFactor.Util + + setup_all do + File.mkdir_p("test/tmp") + + on_exit(fn -> + File.rm_rf("test/tmp") + end) + end + + describe "module_to_string/1" do + test "given a module name, convert it to a string, ensure the Elixir. prefix is not included" do + refute Util.module_to_string(MyMod.SubMod.SubSubMod) =~ "Elixir." + assert Util.module_to_string(MyMod.SubMod.SubSubMod) == "MyMod.SubMod.SubSubMod" + end + end +end