Compare tuples positionally in diff (#9262)

2 files changed, 59 insertions, 20 deletions

diff --git a/lib/ex_unit/lib/ex_unit/diff.ex b/lib/ex_unit/lib/ex_unit/diff.ex
index 2bc96161f..a4cc1ecef 100644
--- a/lib/ex_unit/lib/ex_unit/diff.ex
+++ b/lib/ex_unit/lib/ex_unit/diff.ex
@@ -193,21 +193,66 @@ defmodule ExUnit.Diff do
   # Tuples
 
   defp compare_tuple({:{}, _, left_list}, right, %{context: :match} = env) do
-    compare_tuple_items(left_list, right, env)
+    compare_tuple_items(left_list, Tuple.to_list(right), env)
   end
 
   defp compare_tuple(left, right, env) do
-    compare_tuple_items(Tuple.to_list(left), right, env)
+    compare_tuple_items(Tuple.to_list(left), Tuple.to_list(right), env)
   end
 
-  defp compare_tuple_items(list_left, right, env) do
-    list_right = Tuple.to_list(right)
+  defp compare_tuple_items(list_left, list_right, env) do
+    {compared, non_compared_left, non_compared_right, post_env} =
+      compare_tuple_items_by_index(list_left, list_right, env)
 
-    {diff, list_post_env} = myers_difference_list(list_left, list_right, env)
-    diff_left = {:{}, [], diff.left}
-    diff_right = {:{}, [], diff.right}
+    remaining_diff = compare_tuple_remaining_items(non_compared_left, non_compared_right)
 
-    {%{diff | left: diff_left, right: diff_right}, list_post_env}
+    {build_tuple_result(compared, remaining_diff), post_env}
+  end
+
+  defp compare_tuple_items_by_index(list_left, list_right, env) do
+    {compared, non_compared_left, non_compared_right, post_env} =
+      Enum.reduce(list_left, {[], [], list_right, env}, fn
+        item, {compared, non_compared, [next | continue], acc_env} ->
+          {diff, diff_post_env} = compare_quoted(item, next, acc_env)
+          {[diff | compared], non_compared, continue, diff_post_env}
+
+        item, {compared, non_compared, [], acc_env} ->
+          {compared, [item | non_compared], [], acc_env}
+      end)
+
+    {
+      Enum.reverse(compared),
+      Enum.reverse(non_compared_left),
+      Enum.reverse(non_compared_right),
+      post_env
+    }
+  end
+
+  defp compare_tuple_remaining_items([], []) do
+    %__MODULE__{
+      equivalent?: true,
+      left: {:{}, [], []},
+      right: {:{}, [], []}
+    }
+  end
+
+  defp compare_tuple_remaining_items(left, right) do
+    left = Enum.map(left, &update_diff_meta(&1, true))
+    right = Enum.map(right, &update_diff_meta(&1, true))
+
+    diff_left = {:{}, [], left}
+    diff_right = {:{}, [], right}
+
+    %__MODULE__{equivalent?: false, left: diff_left, right: diff_right}
+  end
+
+  defp build_tuple_result([], remaining_diff) do
+    remaining_diff
+  end
+
+  defp build_tuple_result([head | tail], remaining_diff) do
+    tail_result = build_tuple_result(tail, remaining_diff)
+    prepend_diff(head, tail_result)
   end
 
   # Lists
diff --git a/lib/ex_unit/test/ex_unit/diff_test.exs b/lib/ex_unit/test/ex_unit/diff_test.exs
index 983b01f4f..17cede47a 100644
--- a/lib/ex_unit/test/ex_unit/diff_test.exs
+++ b/lib/ex_unit/test/ex_unit/diff_test.exs
@@ -370,6 +370,8 @@ defmodule ExUnit.DiffTest do
     refute_diff({:a} = {:a, :b}, "{:a}", "{:a, +:b+}")
     refute_diff({:a, :b} = {:a}, "{:a, -:b-}", "{:a}")
 
+    refute_diff({:ok, value} = {:error, :fatal}, "{-:ok-, value}", "{+:error+, :fatal}")
+
     refute_diff({:a, :b} = :a, "-{:a, :b}-", "+:a+")
   end
 
@@ -656,8 +658,8 @@ defmodule ExUnit.DiffTest do
 
     refute_diff(
       {ref1, ref2} == {ref2, ref1},
-      "{-#{inspect_ref1}-, #{inspect_ref2}}",
-      "{#{inspect_ref2}, +#{inspect_ref1}+}"
+      "{-#{inspect_ref1}-, -#{inspect_ref2}-}",
+      "{+#{inspect_ref2}+, +#{inspect_ref1}+}"
     )
 
     refute_diff(
@@ -693,11 +695,7 @@ defmodule ExUnit.DiffTest do
     refute_diff(pid == :a, "-#{inspect_pid}-", "+:a+")
     refute_diff({pid, pid} == :a, "-{#{inspect_pid}, #{inspect_pid}}", "+:a+")
 
-    refute_diff(
-      {pid, :a} == {:a, pid},
-      "{-#{inspect_pid}-, :a}",
-      "{:a, +#{inspect_pid}+}"
-    )
+    refute_diff({pid, :a} == {:a, pid}, "{-#{inspect_pid}-, -:a-}", "{+:a+, +#{inspect_pid}+}")
 
     refute_diff(%{pid => pid} == :a, "-%{#{inspect_pid} => #{inspect_pid}}", "+:a+")
 
@@ -718,11 +716,7 @@ defmodule ExUnit.DiffTest do
     refute_diff(identity == :a, "-#{inspect}-", "+:a+")
     refute_diff({identity, identity} == :a, "-{#{inspect}, #{inspect}}", "+:a+")
 
-    refute_diff(
-      {identity, :a} == {:a, identity},
-      "{-#{inspect}-, :a}",
-      "{:a, +#{inspect}+}"
-    )
+    refute_diff({identity, :a} == {:a, identity}, "{-#{inspect}-, -:a-}", "{+:a+, +#{inspect}+}")
 
     refute_diff(%{identity => identity} == :a, "-%{#{inspect} => #{inspect}}", "+:a+")