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

Display ignored fields as ignored #267

Merged
merged 3 commits into from
Jun 23, 2021
Merged

Display ignored fields as ignored #267

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
5b2472b
Display ignored fields as ignored
ghostbuster91 Jun 22, 2021
57cf2d8
Fix tuple instances and tests
ghostbuster91 Jun 22, 2021
34ce1fc
Fix testFrameworks integrations
ghostbuster91 Jun 23, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion core/src/main/scala/com/softwaremill/diffx/Diff.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,6 @@ trait Diff[-T] { outer =>
object Diff extends MiddlePriorityDiff with TupleInstances {
def apply[T: Diff]: Diff[T] = implicitly[Diff[T]]

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

def compare[T: Diff](left: T, right: T): DiffResult = apply[T].apply(left, right)
Expand Down
38 changes: 23 additions & 15 deletions core/src/main/scala/com/softwaremill/diffx/DiffResult.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,14 +9,16 @@ trait DiffResult extends Product with Serializable {
showIndented(indentLevel, renderIdentical)

private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String

protected def i(indent: Int): String = " " * indent
}

object DiffResult {
private[diffx] final val indentLevel = 5
val Ignored = Identical("<ignored>")
val Ignored: IdenticalValue[Any] = IdenticalValue("<ignored>")
}

case class DiffResultObject(name: String, fields: Map[String, DiffResult]) extends DiffResultDifferent {
case class DiffResultObject(name: String, fields: Map[String, DiffResult]) extends DiffResult {
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
c: ConsoleColorConfig
): String = {
Expand All @@ -41,13 +43,15 @@ case class DiffResultObject(name: String, fields: Map[String, DiffResult]) exten
) = {
s"${i(indent)}${defaultColor(s"$field: ")}"
}

override def isIdentical: Boolean = fields.values.forall(_.isIdentical)
}

case class DiffResultMap(fields: Map[DiffResult, DiffResult]) extends DiffResultDifferent {
case class DiffResultMap(entries: Map[DiffResult, DiffResult]) extends DiffResult {
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
c: ConsoleColorConfig
): String = {
val showFields = fields
val showFields = entries
.filter { case (k, v) =>
renderIdentical || !v.isIdentical || !k.isIdentical
}
Expand All @@ -71,9 +75,11 @@ case class DiffResultMap(fields: Map[DiffResult, DiffResult]) extends DiffResult
) = {
s"${i(indent)}${defaultColor(s"${key.showIndented(indent + indentLevel, renderIdentical)}")}"
}

override def isIdentical: Boolean = entries.forall { case (k, v) => k.isIdentical && v.isIdentical }
}

case class DiffResultSet(diffs: List[DiffResult]) extends DiffResultDifferent {
case class DiffResultSet(diffs: List[DiffResult]) extends DiffResult {
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
c: ConsoleColorConfig
): String = {
Expand All @@ -82,42 +88,44 @@ case class DiffResultSet(diffs: List[DiffResult]) extends DiffResultDifferent {
.map(f => s"${i(indent)}${f.showIndented(indent + indentLevel, renderIdentical)}")
showFields.mkString(defaultColor("Set(\n"), ",\n", defaultColor(")"))
}

override def isIdentical: Boolean = diffs.forall(_.isIdentical)
}

case class DiffResultString(diffs: List[DiffResult]) extends DiffResultDifferent {
case class DiffResultString(diffs: List[DiffResult]) extends DiffResult {
override private[diffx] def showIndented(indent: Int, renderIdentical: Boolean)(implicit
c: ConsoleColorConfig
): String = {
s"${diffs.map(_.showIndented(indent, renderIdentical)).mkString("\n")}"
}
}

trait DiffResultDifferent extends DiffResult {
override def isIdentical: Boolean = false

protected def i(indent: Int): String = " " * indent
override def isIdentical: Boolean = diffs.forall(_.isIdentical)
}

case class DiffResultValue[T](left: T, right: T) extends DiffResultDifferent {
case class DiffResultValue[T](left: T, right: T) extends DiffResult {
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String =
showChange(s"$left", s"$right")

override def isIdentical: Boolean = false
}

case class Identical[T](value: T) extends DiffResult {
case class IdenticalValue[T](value: T) extends DiffResult {
override def isIdentical: Boolean = true

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

case class DiffResultMissing[T](value: T) extends DiffResultDifferent {
case class DiffResultMissing[T](value: T) extends DiffResult {
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String = {
rightColor(s"$value")
}
override def isIdentical: Boolean = false
}

case class DiffResultAdditional[T](value: T) extends DiffResultDifferent {
case class DiffResultAdditional[T](value: T) extends DiffResult {
override def showIndented(indent: Int, renderIdentical: Boolean)(implicit c: ConsoleColorConfig): String = {
leftColor(s"$value")
}
override def isIdentical: Boolean = false
}
2 changes: 1 addition & 1 deletion core/src/main/scala/com/softwaremill/diffx/DiffxSupport.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,7 +12,7 @@ trait DiffxSupport extends DiffxEitherSupport with DiffxConsoleSupport with Diff
if ((left == null && right != null) || (left != null && right == null)) {
DiffResultValue(left, right)
} else if (left == null && right == null) {
Identical(null)
IdenticalValue(null)
} else {
compareNotNull(left, right)
}
Expand Down
122 changes: 21 additions & 101 deletions core/src/main/scala/com/softwaremill/diffx/TupleInstances.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,11 +9,7 @@ trait TupleInstances {
context: DiffContext
): DiffResult = {
val results = List("_1" -> d1.apply(left._1, right._1), "_2" -> d2.apply(left._2, right._2)).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple2", results)
}
DiffResultObject("Tuple2", results)
}
}

Expand All @@ -29,11 +25,7 @@ trait TupleInstances {
"_2" -> d2.apply(left._2, right._2),
"_3" -> d3.apply(left._3, right._3)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple3", results)
}
DiffResultObject("Tuple3", results)
}
}

Expand All @@ -54,11 +46,7 @@ trait TupleInstances {
"_3" -> d3.apply(left._3, right._3),
"_4" -> d4.apply(left._4, right._4)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple4", results)
}
DiffResultObject("Tuple4", results)
}
}

Expand All @@ -81,11 +69,7 @@ trait TupleInstances {
"_4" -> d4.apply(left._4, right._4),
"_5" -> d5.apply(left._5, right._5)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple5", results)
}
DiffResultObject("Tuple5", results)
}
}

Expand All @@ -110,11 +94,7 @@ trait TupleInstances {
"_5" -> d5.apply(left._5, right._5),
"_6" -> d6.apply(left._6, right._6)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple6", results)
}
DiffResultObject("Tuple6", results)
}
}

Expand All @@ -141,11 +121,7 @@ trait TupleInstances {
"_6" -> d6.apply(left._6, right._6),
"_7" -> d7.apply(left._7, right._7)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple7", results)
}
DiffResultObject("Tuple7", results)
}
}

Expand Down Expand Up @@ -174,11 +150,7 @@ trait TupleInstances {
"_7" -> d7.apply(left._7, right._7),
"_8" -> d8.apply(left._8, right._8)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple8", results)
}
DiffResultObject("Tuple8", results)
}
}

Expand Down Expand Up @@ -209,11 +181,7 @@ trait TupleInstances {
"_8" -> d8.apply(left._8, right._8),
"_9" -> d9.apply(left._9, right._9)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple9", results)
}
DiffResultObject("Tuple9", results)
}
}

Expand Down Expand Up @@ -247,11 +215,7 @@ trait TupleInstances {
"_9" -> d9.apply(left._9, right._9),
"_10" -> d10.apply(left._10, right._10)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple10", results)
}
DiffResultObject("Tuple10", results)
}
}

Expand Down Expand Up @@ -287,11 +251,7 @@ trait TupleInstances {
"_10" -> d10.apply(left._10, right._10),
"_11" -> d11.apply(left._11, right._11)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple11", results)
}
DiffResultObject("Tuple11", results)
}
}

Expand Down Expand Up @@ -329,11 +289,7 @@ trait TupleInstances {
"_11" -> d11.apply(left._11, right._11),
"_12" -> d12.apply(left._12, right._12)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple12", results)
}
DiffResultObject("Tuple12", results)
}
}

Expand Down Expand Up @@ -374,7 +330,7 @@ trait TupleInstances {
"_13" -> d13.apply(left._13, right._13)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
IdenticalValue(left)
} else {
DiffResultObject("Tuple13", results)
}
Expand Down Expand Up @@ -419,11 +375,7 @@ trait TupleInstances {
"_13" -> d13.apply(left._13, right._13),
"_14" -> d14.apply(left._14, right._14)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple14", results)
}
DiffResultObject("Tuple14", results)
}
}

Expand Down Expand Up @@ -467,11 +419,7 @@ trait TupleInstances {
"_14" -> d14.apply(left._14, right._14),
"_15" -> d15.apply(left._15, right._15)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple15", results)
}
DiffResultObject("Tuple15", results)
}
}

Expand Down Expand Up @@ -517,11 +465,7 @@ trait TupleInstances {
"_15" -> d15.apply(left._15, right._15),
"_16" -> d16.apply(left._16, right._16)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple16", results)
}
DiffResultObject("Tuple16", results)
}
}

Expand Down Expand Up @@ -569,11 +513,7 @@ trait TupleInstances {
"_16" -> d16.apply(left._16, right._16),
"_17" -> d17.apply(left._17, right._17)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple17", results)
}
DiffResultObject("Tuple17", results)
}
}

Expand Down Expand Up @@ -623,11 +563,7 @@ trait TupleInstances {
"_17" -> d17.apply(left._17, right._17),
"_18" -> d18.apply(left._18, right._18)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple18", results)
}
DiffResultObject("Tuple18", results)
}
}

Expand Down Expand Up @@ -679,11 +615,7 @@ trait TupleInstances {
"_18" -> d18.apply(left._18, right._18),
"_19" -> d19.apply(left._19, right._19)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple19", results)
}
DiffResultObject("Tuple19", results)
}
}

Expand Down Expand Up @@ -738,11 +670,7 @@ trait TupleInstances {
"_19" -> d19.apply(left._19, right._19),
"_20" -> d20.apply(left._20, right._20)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple20", results)
}
DiffResultObject("Tuple20", results)
}
}

Expand Down Expand Up @@ -799,11 +727,7 @@ trait TupleInstances {
"_20" -> d20.apply(left._20, right._20),
"_21" -> d21.apply(left._21, right._21)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple21", results)
}
DiffResultObject("Tuple21", results)
}
}

Expand Down Expand Up @@ -887,11 +811,7 @@ trait TupleInstances {
"_21" -> d21.apply(left._21, right._21),
"_22" -> d22.apply(left._22, right._22)
).toMap
if (results.values.forall(_.isIdentical)) {
Identical(left)
} else {
DiffResultObject("Tuple22", results)
}
DiffResultObject("Tuple22", results)
}
}

Expand Down
Loading