Add comparison of children & text

Author: stringbean

xml-compare/src/main/scala/software/purpledragon/xml/compare/XmlCompare.scala

@@ -3,15 +3,19 @@ package software.purpledragon.xml.compare
 import software.purpledragon.xml.compare.options.DiffOption._
 import software.purpledragon.xml.compare.options.DiffOptions
 
-import scala.xml.Node
+import scala.xml.{Node, Text}
 
 object XmlCompare {
   private type Check = (Node, Node, DiffOptions) => XmlDiff
 
   val DefaultOptions: DiffOptions = Set(IgnorePrefix)
 
   def compare(left: Node, right: Node, options: DiffOptions = DefaultOptions): XmlDiff = {
-    val checks: Seq[Check] = Seq(compareNamespace)
+    val checks: Seq[Check] = Seq(
+      compareNamespace,
+      compareText,
+      compareChildren
+    )
 
     checks.foldLeft[XmlDiff](XmlEqual) { (status, check) =>
       if (!status.isEqual) {
@@ -25,13 +29,44 @@ object XmlCompare {
 
   private def compareNamespace(left: Node, right: Node, options: DiffOptions): XmlDiff = {
     if (left.label != right.label) {
-      XmlDiffers("different label")
+      XmlDiffers("different label", left.label, right.label)
     } else if (left.namespace != right.namespace) {
-      XmlDiffers("different namespace")
+      XmlDiffers("different namespace", left.namespace, right.namespace)
     } else if (left.prefix != right.prefix && !options.contains(IgnorePrefix)) {
-      XmlDiffers("different prefix")
+      XmlDiffers("different prefix", left.prefix, right.prefix)
     } else {
       XmlEqual
     }
   }
+
+  private def compareText(left: Node, right: Node, options: DiffOptions): XmlDiff = {
+    val leftText = left.child.collect({case t: Text => t}).map(_.text.trim).mkString
+    val rightText = right.child.collect({case t: Text => t}).map(_.text.trim).mkString
+
+    if (leftText != rightText) {
+      XmlDiffers("different text", leftText, rightText)
+    } else {
+      XmlEqual
+    }
+  }
+
+  private def compareChildren(left: Node, right: Node, options: DiffOptions): XmlDiff = {
+    val leftChildren = left.child.filterNot(_.isInstanceOf[Text])
+    val rightChildren = right.child.filterNot(_.isInstanceOf[Text])
+
+    if (leftChildren.size != rightChildren.size) {
+      XmlDiffers("child count", leftChildren.size, rightChildren.size)
+    } else {
+      val meh: Seq[(Node, Node)] = leftChildren.zip(rightChildren)
+
+      meh.foldLeft[XmlDiff](XmlEqual) { case (status, (leftChild, rightChild)) =>
+        if (!status.isEqual) {
+          // already failed
+          status
+        } else {
+          compare(leftChild, rightChild, options)
+        }
+      }
+    }
+  }
 }

xml-compare/src/main/scala/software/purpledragon/xml/compare/XmlDiff.scala

@@ -6,8 +6,10 @@ sealed trait XmlDiff {
 
 object XmlEqual extends XmlDiff {
   override def isEqual: Boolean = true
+
+  override def toString: String = "XmlEqual"
 }
 
-case class XmlDiffers(reason: String) extends XmlDiff {
+case class XmlDiffers(reason: String, left: Any, right: Any) extends XmlDiff {
   override def isEqual: Boolean = false
 }

xml-compare/src/test/scala/software/purpledragon/xml/compare/XmlCompareSpec.scala

@@ -4,16 +4,16 @@ import org.scalatest.{FlatSpec, Matchers}
 
 class XmlCompareSpec extends FlatSpec with Matchers {
 
-  "comparing empty" should "match same element name" in {
+  "compare with defaults" should "match same empty element" in {
     XmlCompare.compare(<test/>, <test/>) shouldBe XmlEqual
   }
 
-  it should "blah" in {
+  it should "match empty elements ignoring collapsed" in {
     XmlCompare.compare(<test/>, <test></test>) shouldBe XmlEqual
   }
 
-  it should "not-match" in {
-    XmlCompare.compare(<test/>, <foo/>) shouldBe XmlDiffers("different label")
+  it should "not-match different label" in {
+    XmlCompare.compare(<test/>, <foo/>) shouldBe XmlDiffers("different label", "test", "foo")
   }
 
   it should "match same namespaces" in {
@@ -26,15 +26,44 @@ class XmlCompareSpec extends FlatSpec with Matchers {
         <e:test xmlns:e="http://example.com"/>) shouldBe XmlEqual
   }
 
-  it should "not-match different namespace prefix (with IgnorePrefix disabled)" in {
+  it should "not-match different namespace url" in {
     XmlCompare.compare(
         <t:test xmlns:t="http://example.com"/>,
-        <e:test xmlns:e="http://example.com"/>, Set.empty) shouldBe XmlDiffers("different prefix")
+        <t:test xmlns:t="http://foo.com"/>) shouldBe
+      XmlDiffers(
+        "different namespace",
+        "http://example.com",
+        "http://foo.com")
   }
 
-  it should "not-match different namespace url" in {
+  it should "match with same single child" in {
+    XmlCompare.compare(<test><test2/></test>, <test><test2/></test>) shouldBe XmlEqual
+  }
+
+  it should "not-match with different single child" in {
+    XmlCompare.compare(<test><test2/></test>, <test><foo/></test>) shouldBe XmlDiffers("different label", "test2", "foo")
+  }
+
+  it should "match with same text contents" in {
+    XmlCompare.compare(<test>contents</test>, <test>contents</test>) shouldBe XmlEqual
+  }
+
+  it should "not-match different text contents" in {
+    XmlCompare.compare(<test>contents</test>, <test/>) shouldBe XmlDiffers("different text", "contents", "")
+  }
+
+  it should "match with text content differing only by whitespace" in {
+    XmlCompare.compare(<test>contents  </test>, <test>contents</test>) shouldBe XmlEqual
+  }
+
+  it should "match with child & text content in different order" in {
+    XmlCompare.compare(<test><test2/>contents</test>, <test>contents<test2/></test>) shouldBe XmlEqual
+  }
+
+
+  "compare without IgnorePrefix" should "not-match different namespace prefix" in {
     XmlCompare.compare(
         <t:test xmlns:t="http://example.com"/>,
-        <t:test xmlns:t="http://foo.com"/>) shouldBe XmlDiffers("different namespace")
+        <e:test xmlns:e="http://example.com"/>, Set.empty) shouldBe XmlDiffers("different prefix", "t", "e")
   }
 }