From 62914c622131828ab6323b5f0f25be978a918182 Mon Sep 17 00:00:00 2001
From: Jacob Wang <jatcwang@gmail.com>
Date: Tue, 27 Jul 2021 13:26:09 +0100
Subject: [PATCH] Add always ignore differ

---
 .gitignore                                    |  1 +
 .../difflicious/AlwaysIgnoreDiffer.scala      | 27 +++++++++++++
 .../src/main/scala/difflicious/Differ.scala   |  3 ++
 .../test/scala/difflicious/DifferSpec.scala   | 40 +++++++++++++++++++
 .../test/scala/difflicious/testtypes.scala    |  6 +++
 5 files changed, 77 insertions(+)
 create mode 100644 modules/core/src/main/scala/difflicious/AlwaysIgnoreDiffer.scala

diff --git a/.gitignore b/.gitignore
index d7099ad..f16e6d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,5 +21,6 @@ projectFilesBackup/
 version.properties
 RUNNING_PID
 .metals
+metals.sbt
 .bsp
 TempGo.scala
diff --git a/modules/core/src/main/scala/difflicious/AlwaysIgnoreDiffer.scala b/modules/core/src/main/scala/difflicious/AlwaysIgnoreDiffer.scala
new file mode 100644
index 0000000..f03d5d2
--- /dev/null
+++ b/modules/core/src/main/scala/difflicious/AlwaysIgnoreDiffer.scala
@@ -0,0 +1,27 @@
+package difflicious
+
+import difflicious.DiffResult.ValueResult
+
+/** A Differ that always return an Ignored result.
+  * Useful when you can't really diff a type */
+final class AlwaysIgnoreDiffer[T] extends Differ[T] {
+  override type R = ValueResult
+
+  override def diff(inputs: DiffInput[T]): ValueResult =
+    ValueResult.Both("[ALWAYS IGNORED]", "[ALWAYS IGNORED]", isSame = true, isIgnored = true)
+
+  override protected def configureIgnored(newIgnored: Boolean): Differ[T] = this
+
+  override protected def configurePath(
+    step: String,
+    nextPath: ConfigurePath,
+    op: ConfigureOp,
+  ): Either[ConfigureError, Differ[T]] = Left(ConfigureError.PathTooLong(nextPath))
+
+  override protected def configurePairBy(
+    path: ConfigurePath,
+    op: ConfigureOp.PairBy[_],
+  ): Either[ConfigureError, Differ[T]] = {
+    Left(ConfigureError.InvalidConfigureOp(path, op, "AlwaysIgnoreDiffer"))
+  }
+}
diff --git a/modules/core/src/main/scala/difflicious/Differ.scala b/modules/core/src/main/scala/difflicious/Differ.scala
index 3b9384f..5a51f4d 100644
--- a/modules/core/src/main/scala/difflicious/Differ.scala
+++ b/modules/core/src/main/scala/difflicious/Differ.scala
@@ -55,6 +55,9 @@ object Differ extends DifferTupleInstances with DifferGen with DifferTimeInstanc
   def useEquals[T](valueToString: T => String): EqualsDiffer[T] =
     new EqualsDiffer[T](isIgnored = false, valueToString = valueToString)
 
+  /** A Differ that always return an Ignored result. Useful when you can't really diff something */
+  def alwaysIgnore[T]: AlwaysIgnoreDiffer[T] = new AlwaysIgnoreDiffer[T]
+
   // TODO: better string diff (edit distance and a description of how to get there?
   //  this can help especially in cases like extra space or special char)
   implicit val stringDiffer: ValueDiffer[String] = useEquals[String](str => s""""$str"""")
diff --git a/modules/coretest/src/test/scala/difflicious/DifferSpec.scala b/modules/coretest/src/test/scala/difflicious/DifferSpec.scala
index 6a445e7..2b4fa79 100644
--- a/modules/coretest/src/test/scala/difflicious/DifferSpec.scala
+++ b/modules/coretest/src/test/scala/difflicious/DifferSpec.scala
@@ -830,4 +830,44 @@ class DifferSpec extends ScalaCheckSuite {
     assertIsOkIfIgnoredProp(NewInt.differ)
   }
 
+  test("Differ.alwaysIgnore: Always returns ignored result") {
+    assertEquals(
+      AlwaysIgnoreClass.differ.diff(AlwaysIgnoreClass(1), AlwaysIgnoreClass(2)),
+      DiffResult.ValueResult.Both(
+        "[ALWAYS IGNORED]",
+        "[ALWAYS IGNORED]",
+        isSame = true,
+        isIgnored = true,
+      ),
+    )
+  }
+
+  test("Differ.alwaysIgnore: still return ignored result after unignore") {
+    assertEquals(
+      AlwaysIgnoreClass.differ.unignore.diff(AlwaysIgnoreClass(1), AlwaysIgnoreClass(2)): DiffResult,
+      DiffResult.ValueResult.Both(
+        "[ALWAYS IGNORED]",
+        "[ALWAYS IGNORED]",
+        isSame = true,
+        isIgnored = true,
+      ),
+    )
+  }
+
+  test("Differ.alwaysIgnore: configurePath returns PathTooLong error") {
+    assertEquals(
+      intercept[ConfigureError](
+        AlwaysIgnoreClass.differ.configure(_.i)(_.ignore),
+      ),
+      ConfigureError.PathTooLong(ConfigurePath(Vector("i"), Nil)),
+    )
+  }
+
+  test("Differ.alwaysIgnore: configurePairBy returns InvalidConfigureOp error") {
+    assertEquals(
+      AlwaysIgnoreClass.differ.configureRaw(ConfigurePath.current, ConfigureOp.PairBy.Index),
+      Left(ConfigureError.InvalidConfigureOp(ConfigurePath.current, ConfigureOp.PairBy.Index, "AlwaysIgnoreDiffer")),
+    )
+  }
+
 }
diff --git a/modules/coretest/src/test/scala/difflicious/testtypes.scala b/modules/coretest/src/test/scala/difflicious/testtypes.scala
index 1bd148e..f9c24c0 100644
--- a/modules/coretest/src/test/scala/difflicious/testtypes.scala
+++ b/modules/coretest/src/test/scala/difflicious/testtypes.scala
@@ -127,4 +127,10 @@ object testtypes {
 
   final case class OpenSub(i: Int) extends OpenSuperType
 
+  case class AlwaysIgnoreClass(i: Int)
+
+  object AlwaysIgnoreClass {
+    implicit val differ: AlwaysIgnoreDiffer[AlwaysIgnoreClass] = Differ.alwaysIgnore
+  }
+
 }