compare correctly lists with duplicates using objectMatcher

Author: ghostbuster91

core/src/main/scala/com/softwaremill/diffx/Matching.scala

@@ -16,19 +16,6 @@ private[diffx] object Matching {
     MatchingResults(left.diff(matchedKeys.map(_._1)), right.diff(matchedKeys.map(_._2)), matchedKeys)
   }
 
-  private[diffx] def matching[T](
-      left: scala.collection.Set[T],
-      right: scala.collection.Set[T],
-      matcher: ObjectMatcher[T]
-  ): MatchingResults[T] = {
-    val matchedKeys = left.flatMap(l =>
-      right.collectFirst {
-        case r if matcher.isSameObject(l, r) => l -> r
-      }
-    )
-    MatchingResults(left.diff(matchedKeys.map(_._1)), right.diff(matchedKeys.map(_._2)), matchedKeys)
-  }
-
   private[diffx] case class MatchingResults[T](
       unmatchedLeft: scala.collection.Set[T],
       unmatchedRight: scala.collection.Set[T],

core/src/main/scala/com/softwaremill/diffx/instances/DiffForIterable.scala

@@ -1,9 +1,10 @@
 package com.softwaremill.diffx.instances
 
-import com.softwaremill.diffx.Matching.{MatchingResults, matching}
+import com.softwaremill.diffx.Matching.MatchingResults
 import com.softwaremill.diffx.ObjectMatcher.{IterableEntry, MapEntry}
 import com.softwaremill.diffx._
 
+import scala.annotation.tailrec
 import scala.collection.immutable.{ListMap, ListSet}
 
 private[diffx] class DiffForIterable[T, C[W] <: Iterable[W]](
@@ -16,12 +17,12 @@ private[diffx] class DiffForIterable[T, C[W] <: Iterable[W]](
 
       val leftAsMap = left.toList.lift
       val rightAsMap = right.toList.lift
-      val leftv2 = ListSet(keys.map(i => i -> leftAsMap(i)): _*).collect { case (k, Some(v)) => MapEntry(k, v) }
-      val rightv2 = ListSet(keys.map(i => i -> rightAsMap(i)): _*).collect { case (k, Some(v)) => MapEntry(k, v) }
+      val lEntries = keys.map(i => i -> leftAsMap(i)).collect { case (k, Some(v)) => MapEntry(k, v) }.toList
+      val rEntries = keys.map(i => i -> rightAsMap(i)).collect { case (k, Some(v)) => MapEntry(k, v) }.toList
 
       val adjustedMatcher = context.getMatcherOverride[IterableEntry[T]].getOrElse(matcher)
       val MatchingResults(unMatchedLeftInstances, unMatchedRightInstances, matchedInstances) =
-        matching(leftv2, rightv2, adjustedMatcher)
+        matchPairs(lEntries, rEntries, adjustedMatcher)
       val leftDiffs = unMatchedLeftInstances
         .diff(unMatchedRightInstances)
         .collectFirst { case MapEntry(k, v) => k -> DiffResultAdditional(v) }
@@ -35,4 +36,32 @@ private[diffx] class DiffForIterable[T, C[W] <: Iterable[W]](
       val diffs = ListMap((matchedDiffs ++ leftDiffs ++ rightDiffs).map { case (k, v) => k.toString -> v }: _*)
       DiffResultObject("List", diffs)
   }
+
+  private def matchPairs(
+      left: List[IterableEntry[T]],
+      right: List[IterableEntry[T]],
+      matcher: ObjectMatcher[IterableEntry[T]]
+  ): MatchingResults[IterableEntry[T]] = {
+    @tailrec
+    def loop(
+        left: List[IterableEntry[T]],
+        right: List[IterableEntry[T]],
+        matches: List[(IterableEntry[T], IterableEntry[T])],
+        leftUnmatched: List[IterableEntry[T]]
+    ): MatchingResults[IterableEntry[T]] = {
+      left match {
+        case lHead :: tail =>
+          val maybeMatch = right.collectFirst {
+            case r if matcher.isSameObject(lHead, r) => lHead -> r
+          }
+          maybeMatch match {
+            case Some(m @ (_, rm)) =>
+              loop(tail, right.filterNot(r => r.key == rm.key), matches :+ m, leftUnmatched)
+            case None => loop(tail, right, matches, leftUnmatched :+ lHead)
+          }
+        case Nil => MatchingResults(ListSet(leftUnmatched: _*), ListSet(right: _*), ListSet(matches: _*))
+      }
+    }
+    loop(left, right, List.empty, List.empty)
+  }
 }

core/src/test/scala/com/softwaremill/diffx/test/DiffTest.scala

@@ -395,6 +395,22 @@ class DiffTest extends AnyFreeSpec with Matchers {
         compare(o1, o2).isIdentical shouldBe true
       }
 
+      "compare lists using value object matcher" in {
+        val p2WithSameNameAsP1 = p2.copy(name = p1.name)
+        val o1 = Organization(List(p1, p2WithSameNameAsP1))
+        val o2 = Organization(List(p2WithSameNameAsP1, p1))
+        implicit val om: ObjectMatcher[IterableEntry[Person]] = ObjectMatcher.byValue(identity(_))
+        compare(o1, o2).isIdentical shouldBe true
+      }
+
+      "compare correctly lists with duplicates using objectMatcher" in {
+        val o1 = Organization(List(p1, p1))
+        val o2 = Organization(List(p1, p1))
+        implicit val om: ObjectMatcher[IterableEntry[Person]] = ObjectMatcher.byValue(identity(_))
+        val result = compare(o1, o2)
+        result.isIdentical shouldBe true
+      }
+
       "should preserve order of elements" in {
         val l1 = List(1, 2, 3, 4, 5, 6)
         val l2 = List(1, 2, 3, 4, 5, 7)