Skip to content
This repository was archived by the owner on Jan 24, 2025. It is now read-only.

Commit 5b2472b

Browse files
ghostbuster91ghostbuster91
committed
Display ignored fields as ignored
1 parent 80042d2 commit 5b2472b

File tree

18 files changed

+309
-192
lines changed

18 files changed

+309
-192
lines changed

‎core/src/main/scala/com/softwaremill/diffx/Diff.scala

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,6 @@ trait Diff[-T] { outer =>
3131
object Diff extends MiddlePriorityDiff with TupleInstances {
3232
def apply[T: Diff]: Diff[T] = implicitly[Diff[T]]
3333

34-
def identical[T]: Diff[T] = (left: T, _: T, _: DiffContext) => Identical(left)
3534
def ignored[T]: Diff[T] = (_: T, _: T, _: DiffContext) => DiffResult.Ignored
3635

3736
def compare[T: Diff](left: T, right: T): DiffResult = apply[T].apply(left, right)

‎core/src/main/scala/com/softwaremill/diffx/DiffResult.scala

Lines changed: 23 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -9,14 +9,16 @@ trait DiffResult extends Product with Serializable {
99
showIndented(indentLevel, renderIdentical)
1010

1111
private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String
12+
13+
protected def i(indent: Int): String = " " * indent
1214
}
1315

1416
object DiffResult {
1517
private[diffx] final val indentLevel = 5
16-
val Ignored = Identical("<ignored>")
18+
val Ignored: IdenticalValue[Any] = IdenticalValue("<ignored>")
1719
}
1820

19-
case class DiffResultObject(name: String, fields: Map[String, DiffResult]) extends DiffResultDifferent {
21+
case class DiffResultObject(name: String, fields: Map[String, DiffResult]) extends DiffResult {
2022
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
2123
c: ConsoleColorConfig
2224
): String = {
@@ -41,13 +43,15 @@ case class DiffResultObject(name: String, fields: Map[String, DiffResult]) exten
4143
) = {
4244
s"${i(indent)}${defaultColor(s"$field: ")}"
4345
}
46+
47+
override def isIdentical: Boolean = fields.values.forall(_.isIdentical)
4448
}
4549

46-
case class DiffResultMap(fields: Map[DiffResult, DiffResult]) extends DiffResultDifferent {
50+
case class DiffResultMap(entries: Map[DiffResult, DiffResult]) extends DiffResult {
4751
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
4852
c: ConsoleColorConfig
4953
): String = {
50-
val showFields = fields
54+
val showFields = entries
5155
.filter { case (k, v) =>
5256
renderIdentical || !v.isIdentical || !k.isIdentical
5357
}
@@ -71,9 +75,11 @@ case class DiffResultMap(fields: Map[DiffResult, DiffResult]) extends DiffResult
7175
) = {
7276
s"${i(indent)}${defaultColor(s"${key.showIndented(indent + indentLevel, renderIdentical)}")}"
7377
}
78+
79+
override def isIdentical: Boolean = entries.forall { case (k, v) => k.isIdentical && v.isIdentical }
7480
}
7581

76-
case class DiffResultSet(diffs: List[DiffResult]) extends DiffResultDifferent {
82+
case class DiffResultSet(diffs: List[DiffResult]) extends DiffResult {
7783
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
7884
c: ConsoleColorConfig
7985
): String = {
@@ -82,42 +88,44 @@ case class DiffResultSet(diffs: List[DiffResult]) extends DiffResultDifferent {
8288
.map(f => s"${i(indent)}${f.showIndented(indent + indentLevel, renderIdentical)}")
8389
showFields.mkString(defaultColor("Set(\n"), ",\n", defaultColor(")"))
8490
}
91+
92+
override def isIdentical: Boolean = diffs.forall(_.isIdentical)
8593
}
8694

87-
case class DiffResultString(diffs: List[DiffResult]) extends DiffResultDifferent {
95+
case class DiffResultString(diffs: List[DiffResult]) extends DiffResult {
8896
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
8997
c: ConsoleColorConfig
9098
): String = {
9199
s"${diffs.map(_.showIndented(indent, renderIdentical)).mkString("\n")}"
92100
}
93-
}
94101

95-
trait DiffResultDifferent extends DiffResult {
96-
override def isIdentical: Boolean = false
97-
98-
protected def i(indent: Int): String = " " * indent
102+
override def isIdentical: Boolean = diffs.forall(_.isIdentical)
99103
}
100104

101-
case class DiffResultValue[T](left: T, right: T) extends DiffResultDifferent {
105+
case class DiffResultValue[T](left: T, right: T) extends DiffResult {
102106
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String =
103107
showChange(s"$left", s"$right")
108+
109+
override def isIdentical: Boolean = false
104110
}
105111

106-
case class Identical[T](value: T) extends DiffResult {
112+
case class IdenticalValue[T](value: T) extends DiffResult {
107113
override def isIdentical: Boolean = true
108114

109115
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String =
110116
defaultColor(s"$value")
111117
}
112118

113-
case class DiffResultMissing[T](value: T) extends DiffResultDifferent {
119+
case class DiffResultMissing[T](value: T) extends DiffResult {
114120
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String = {
115121
rightColor(s"$value")
116122
}
123+
override def isIdentical: Boolean = false
117124
}
118125

119-
case class DiffResultAdditional[T](value: T) extends DiffResultDifferent {
126+
case class DiffResultAdditional[T](value: T) extends DiffResult {
120127
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String = {
121128
leftColor(s"$value")
122129
}
130+
override def isIdentical: Boolean = false
123131
}

‎core/src/main/scala/com/softwaremill/diffx/DiffxSupport.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ trait DiffxSupport extends DiffxEitherSupport with DiffxConsoleSupport with Diff
1212
if ((left == null && right != null) || (left != null && right == null)) {
1313
DiffResultValue(left, right)
1414
} else if (left == null && right == null) {
15-
Identical(null)
15+
IdenticalValue(null)
1616
} else {
1717
compareNotNull(left, right)
1818
}

‎core/src/main/scala/com/softwaremill/diffx/TupleInstances.scala

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ trait TupleInstances {
1010
): DiffResult = {
1111
val results = List("_1" -> d1.apply(left._1, right._1), "_2" -> d2.apply(left._2, right._2)).toMap
1212
if (results.values.forall(_.isIdentical)) {
13-
Identical(left)
13+
IdenticalValue(left)
1414
} else {
1515
DiffResultObject("Tuple2", results)
1616
}
@@ -30,7 +30,7 @@ trait TupleInstances {
3030
"_3" -> d3.apply(left._3, right._3)
3131
).toMap
3232
if (results.values.forall(_.isIdentical)) {
33-
Identical(left)
33+
IdenticalValue(left)
3434
} else {
3535
DiffResultObject("Tuple3", results)
3636
}
@@ -55,7 +55,7 @@ trait TupleInstances {
5555
"_4" -> d4.apply(left._4, right._4)
5656
).toMap
5757
if (results.values.forall(_.isIdentical)) {
58-
Identical(left)
58+
IdenticalValue(left)
5959
} else {
6060
DiffResultObject("Tuple4", results)
6161
}
@@ -82,7 +82,7 @@ trait TupleInstances {
8282
"_5" -> d5.apply(left._5, right._5)
8383
).toMap
8484
if (results.values.forall(_.isIdentical)) {
85-
Identical(left)
85+
IdenticalValue(left)
8686
} else {
8787
DiffResultObject("Tuple5", results)
8888
}
@@ -111,7 +111,7 @@ trait TupleInstances {
111111
"_6" -> d6.apply(left._6, right._6)
112112
).toMap
113113
if (results.values.forall(_.isIdentical)) {
114-
Identical(left)
114+
IdenticalValue(left)
115115
} else {
116116
DiffResultObject("Tuple6", results)
117117
}
@@ -142,7 +142,7 @@ trait TupleInstances {
142142
"_7" -> d7.apply(left._7, right._7)
143143
).toMap
144144
if (results.values.forall(_.isIdentical)) {
145-
Identical(left)
145+
IdenticalValue(left)
146146
} else {
147147
DiffResultObject("Tuple7", results)
148148
}
@@ -175,7 +175,7 @@ trait TupleInstances {
175175
"_8" -> d8.apply(left._8, right._8)
176176
).toMap
177177
if (results.values.forall(_.isIdentical)) {
178-
Identical(left)
178+
IdenticalValue(left)
179179
} else {
180180
DiffResultObject("Tuple8", results)
181181
}
@@ -210,7 +210,7 @@ trait TupleInstances {
210210
"_9" -> d9.apply(left._9, right._9)
211211
).toMap
212212
if (results.values.forall(_.isIdentical)) {
213-
Identical(left)
213+
IdenticalValue(left)
214214
} else {
215215
DiffResultObject("Tuple9", results)
216216
}
@@ -248,7 +248,7 @@ trait TupleInstances {
248248
"_10" -> d10.apply(left._10, right._10)
249249
).toMap
250250
if (results.values.forall(_.isIdentical)) {
251-
Identical(left)
251+
IdenticalValue(left)
252252
} else {
253253
DiffResultObject("Tuple10", results)
254254
}
@@ -288,7 +288,7 @@ trait TupleInstances {
288288
"_11" -> d11.apply(left._11, right._11)
289289
).toMap
290290
if (results.values.forall(_.isIdentical)) {
291-
Identical(left)
291+
IdenticalValue(left)
292292
} else {
293293
DiffResultObject("Tuple11", results)
294294
}
@@ -330,7 +330,7 @@ trait TupleInstances {
330330
"_12" -> d12.apply(left._12, right._12)
331331
).toMap
332332
if (results.values.forall(_.isIdentical)) {
333-
Identical(left)
333+
IdenticalValue(left)
334334
} else {
335335
DiffResultObject("Tuple12", results)
336336
}
@@ -374,7 +374,7 @@ trait TupleInstances {
374374
"_13" -> d13.apply(left._13, right._13)
375375
).toMap
376376
if (results.values.forall(_.isIdentical)) {
377-
Identical(left)
377+
IdenticalValue(left)
378378
} else {
379379
DiffResultObject("Tuple13", results)
380380
}
@@ -420,7 +420,7 @@ trait TupleInstances {
420420
"_14" -> d14.apply(left._14, right._14)
421421
).toMap
422422
if (results.values.forall(_.isIdentical)) {
423-
Identical(left)
423+
IdenticalValue(left)
424424
} else {
425425
DiffResultObject("Tuple14", results)
426426
}
@@ -468,7 +468,7 @@ trait TupleInstances {
468468
"_15" -> d15.apply(left._15, right._15)
469469
).toMap
470470
if (results.values.forall(_.isIdentical)) {
471-
Identical(left)
471+
IdenticalValue(left)
472472
} else {
473473
DiffResultObject("Tuple15", results)
474474
}
@@ -518,7 +518,7 @@ trait TupleInstances {
518518
"_16" -> d16.apply(left._16, right._16)
519519
).toMap
520520
if (results.values.forall(_.isIdentical)) {
521-
Identical(left)
521+
IdenticalValue(left)
522522
} else {
523523
DiffResultObject("Tuple16", results)
524524
}
@@ -570,7 +570,7 @@ trait TupleInstances {
570570
"_17" -> d17.apply(left._17, right._17)
571571
).toMap
572572
if (results.values.forall(_.isIdentical)) {
573-
Identical(left)
573+
IdenticalValue(left)
574574
} else {
575575
DiffResultObject("Tuple17", results)
576576
}
@@ -624,7 +624,7 @@ trait TupleInstances {
624624
"_18" -> d18.apply(left._18, right._18)
625625
).toMap
626626
if (results.values.forall(_.isIdentical)) {
627-
Identical(left)
627+
IdenticalValue(left)
628628
} else {
629629
DiffResultObject("Tuple18", results)
630630
}
@@ -680,7 +680,7 @@ trait TupleInstances {
680680
"_19" -> d19.apply(left._19, right._19)
681681
).toMap
682682
if (results.values.forall(_.isIdentical)) {
683-
Identical(left)
683+
IdenticalValue(left)
684684
} else {
685685
DiffResultObject("Tuple19", results)
686686
}
@@ -739,7 +739,7 @@ trait TupleInstances {
739739
"_20" -> d20.apply(left._20, right._20)
740740
).toMap
741741
if (results.values.forall(_.isIdentical)) {
742-
Identical(left)
742+
IdenticalValue(left)
743743
} else {
744744
DiffResultObject("Tuple20", results)
745745
}
@@ -800,7 +800,7 @@ trait TupleInstances {
800800
"_21" -> d21.apply(left._21, right._21)
801801
).toMap
802802
if (results.values.forall(_.isIdentical)) {
803-
Identical(left)
803+
IdenticalValue(left)
804804
} else {
805805
DiffResultObject("Tuple21", results)
806806
}
@@ -888,7 +888,7 @@ trait TupleInstances {
888888
"_22" -> d22.apply(left._22, right._22)
889889
).toMap
890890
if (results.values.forall(_.isIdentical)) {
891-
Identical(left)
891+
IdenticalValue(left)
892892
} else {
893893
DiffResultObject("Tuple22", results)
894894
}

‎core/src/main/scala/com/softwaremill/diffx/generic/DiffMagnoliaDerivation.scala

Lines changed: 11 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,14 @@
11
package com.softwaremill.diffx.generic
22

3-
import com.softwaremill.diffx.{Diff, DiffContext, DiffResultObject, DiffResultValue, FieldPath, Identical, nullGuard}
3+
import com.softwaremill.diffx.{
4+
Diff,
5+
DiffContext,
6+
DiffResultObject,
7+
DiffResultValue,
8+
FieldPath,
9+
IdenticalValue,
10+
nullGuard
11+
}
412
import magnolia._
513

614
import scala.collection.immutable.ListMap
@@ -16,11 +24,7 @@ trait DiffMagnoliaDerivation extends LowPriority {
1624
val fieldDiff = context.getOverride(p.label).map(_.asInstanceOf[Diff[p.PType]]).getOrElse(p.typeclass)
1725
p.label -> fieldDiff(lType, pType, context.getNextStep(p.label))
1826
}: _*)
19-
if (map.values.forall(p => p.isIdentical)) {
20-
Identical(left)
21-
} else {
22-
DiffResultObject(ctx.typeName.short, map)
23-
}
27+
DiffResultObject(ctx.typeName.short, map)
2428
}
2529
}
2630

@@ -43,7 +47,7 @@ trait LowPriority {
4347
if (left != right) {
4448
DiffResultValue(left, right)
4549
} else {
46-
Identical(left)
50+
IdenticalValue(left)
4751
}
4852
}
4953
}

‎core/src/main/scala/com/softwaremill/diffx/instances/ApproximateDiffForNumeric.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ private[diffx] class ApproximateDiffForNumeric[T: Numeric](epsilon: T) extends D
88
if (numeric.lt(epsilon, numeric.abs(numeric.minus(left, right)))) {
99
DiffResultValue(left, right)
1010
} else {
11-
Identical(left)
11+
IdenticalValue(left)
1212
}
1313
}
1414
}

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

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -32,10 +32,6 @@ private[diffx] class DiffForIterable[T, C[W] <: Iterable[W]](
3232
val matchedDiffs = matchedInstances.map { case (l, r) => l._1 -> dt(l._2, r._2, context) }.toList
3333

3434
val diffs = ListMap((matchedDiffs ++ leftDiffs ++ rightDiffs).map { case (k, v) => k.toString -> v }: _*)
35-
if (diffs.forall { case (_, v) => v.isIdentical }) {
36-
Identical(left)
37-
} else {
38-
DiffResultObject("List", diffs)
39-
}
35+
DiffResultObject("List", diffs)
4036
}
4137
}

‎core/src/main/scala/com/softwaremill/diffx/instances/DiffForMap.scala

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -28,10 +28,6 @@ private[diffx] class DiffForMap[K, V, C[KK, VV] <: scala.collection.Map[KK, VV]]
2828
val matchedDiffs = matchedKeys.map { case (l, r) => diffKey(l._1, r._1) -> diffValue(l._2, r._2, context) }.toList
2929

3030
val diffs = leftDiffs ++ rightDiffs ++ matchedDiffs
31-
if (diffs.forall(p => p._1.isIdentical && p._2.isIdentical)) {
32-
Identical(left)
33-
} else {
34-
DiffResultMap(diffs.toMap)
35-
}
31+
DiffResultMap(diffs.toMap)
3632
}
3733
}

‎core/src/main/scala/com/softwaremill/diffx/instances/DiffForNumeric.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ private[diffx] class DiffForNumeric[T: Numeric] extends Diff[T] {
88
if (!numeric.equiv(left, right)) {
99
DiffResultValue(left, right)
1010
} else {
11-
Identical(left)
11+
IdenticalValue(left)
1212
}
1313
}
1414
}

‎core/src/main/scala/com/softwaremill/diffx/instances/DiffForOption.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ private[diffx] class DiffForOption[T](dt: Diff[T]) extends Diff[Option[T]] {
66
override def apply(left: Option[T], right: Option[T], context: DiffContext): DiffResult = {
77
(left, right) match {
88
case (Some(l), Some(r)) => dt.apply(l, r, context)
9-
case (None, None) => Identical(None)
9+
case (None, None) => IdenticalValue(None)
1010
case (l, r) => DiffResultValue(l, r)
1111
}
1212
}

0 commit comments

Comments
 (0)