add some test

rewrite XmlPath to more functional implementation

Author: Andrey Onistchuk

project/ScalaXmlDiffBuild.scala

@@ -48,7 +48,7 @@ object ScalaXmlDiffBuild extends Build {
 
   object BuildSettings {
 
-    val ver = "1.1.2"
+    val ver = "1.1.3"
 
     lazy val settings = Defaults.coreDefaultSettings ++ Seq(
       version := ver,

src/main/scala/com/github/andyglow/xml/diff/XmlComparator.scala

@@ -17,6 +17,8 @@
  */
 package com.github.andyglow.xml.diff
 
+import XmlDiff._
+
 case class XmlComparisonContext(path: List[xml.Node] = Nil) {
   def append(node: xml.Node): XmlComparisonContext = this.copy(path = node :: path)
 }
@@ -44,41 +46,39 @@ class XmlComparator(
   private def compareChildren(
     context: XmlComparisonContext,
     expected: List[xml.Node],
-    actual: List[xml.Node]): XmlDiff = {
+    actual: List[xml.Node]): XmlDiffResult = {
 
     expected match {
       case e :: tail =>
         e match {
           case e: xml.Elem if !shouldSkip(context, e) => findMatchingNode(context, tail, actual, e)
-          case xml.Text(_t) if _t.trim.isEmpty => NoDiff // ???
+          case xml.Text(_t) if _t.trim.isEmpty => XmlEqual
           case _ => compare(e, actual.head, context)
         }
-      case Nil => NoDiff
+      case Nil => XmlEqual
     }
   }
 
   private def findMatchingNode(
     context: XmlComparisonContext,
     expected: List[xml.Node],
     actual: List[xml.Node],
-    e: xml.Node): XmlDiff = {
+    e: xml.Node): XmlDiffResult = {
 
     val comparison = actual.filter {
       case a: xml.Node => isNodeNamesEqual(context, e, a)
       case _ => false
-    } map { n =>
-      val diff = compare(e, n, context)
-      (n, diff)
-    }
+    } map { n => (n, compare(e, n, context)) }
 
     if (comparison.isEmpty)
-      NodeNotFound(context.path, e)
+      XmlDifferent(AbsentNode(context.path, e))
     else {
-      val sortOfSimilar = comparison.map(_._2)
-      val matched = sortOfSimilar.find(_ == NoDiff)
-      matched match {
-        case Some(NoDiff) => compareChildren(context, expected, actual.dropWhile(n=>comparison.exists(_._1 == n)))
-        case _ => ChildrenDiff(context.path, e, sortOfSimilar)
+      def diffs = comparison collect { case (_, XmlDifferent(diff)) => diff }
+      val hasEquals = comparison collectFirst { case (_, XmlEqual) => true } getOrElse false
+      if (hasEquals) {
+        compareChildren(context, expected, actual.dropWhile(n => comparison.exists { case (node, _) => node == n }))
+      } else {
+        XmlDifferent(ChildrenDiff(context.path, e, diffs))
       }
     }
   }
@@ -106,37 +106,37 @@ class XmlComparator(
     }
   }
 
-  def compare(expected: xml.Node, actual: xml.Node, context: XmlComparisonContext = XmlComparisonContext()): XmlDiff = {
+  def compare(expected: xml.Node, actual: xml.Node, context: XmlComparisonContext = XmlComparisonContext()): XmlDiffResult = {
     (expected, actual) match {
 
       case (xml.Comment(_), _) | (_, xml.Comment(_)) =>
-        NoDiff
+        XmlEqual
 
       case (xml.Text(t1), xml.Text(t2)) =>
         if (ignoreTextDiffs || t1.trim == t2.trim)
-          NoDiff 
+          XmlEqual
         else
-          NodeDiff(context.path, expected, actual)
+          XmlDifferent(NodeDiff(context.path, expected, actual))
 
       case (e1: xml.Elem, e2: xml.Elem) =>
         val next = context.append(e1)
 
         if (shouldSkip(next, e1))
-          NoDiff
+          XmlEqual
         else if (isNodeNamesEqual(next, e1, e2)) {
           if (isAttrsEqual(e1, e2))
             compareChildren(next, e1.child.toList, e2.child.toList)
           else
-            AttributesDiff(next.path, e1.attributes, e2.attributes)
+            XmlDifferent(AttributesDiff(next.path, e1.attributes, e2.attributes))
         } else {
-          NodeDiff(next.path, e1, e2)
+          XmlDifferent(NodeDiff(next.path, e1, e2))
         }
 
       case (e1: xml.Node, e2: xml.Node) =>
         if (ignoreTextDiffs || e1.text == e2.text)
-          NoDiff 
+          XmlEqual
         else
-          NodeDiff(context.path, e1, e2)
+          XmlDifferent(NodeDiff(context.path, e1, e2))
 
     }
   }

src/main/scala/com/github/andyglow/xml/diff/XmlDiff.scala

@@ -17,11 +17,12 @@
  */
 package com.github.andyglow.xml.diff
 
-sealed trait XmlDiff
+sealed trait XmlDiffResult
 
-case object NoDiff extends XmlDiff
+case object XmlEqual extends XmlDiffResult
+case class XmlDifferent(diff: XmlDiff) extends XmlDiffResult
 
-sealed trait TheDiff extends XmlDiff {
+sealed trait XmlDiff {
   def path: List[xml.Node]
 }
 
@@ -31,37 +32,40 @@ private[diff] object XmlDiff {
     def name: String = n.nameToString(new StringBuilder).toString()
   }
 
-}
+  case class RedundantNode(path: List[xml.Node], node: xml.Node) extends XmlDiff {
+    override def toString = s"""RedundantNode(
+                                |   $node
+                                |)""".stripMargin
+  }
 
-case class IllegalNodeFound(path: List[xml.Node], node: xml.Node) extends TheDiff {
-  override def toString = s"""IllegalNodeFound(
-      |   ${node}
-      |)""".stripMargin
-}
+  case class AbsentNode(path: List[xml.Node], node: xml.Node) extends XmlDiff {
+    override def toString = s"""AbsentNode(
+                                |   $node
+                                |)""".stripMargin
+  }
 
-case class NodeNotFound(path: List[xml.Node], node: xml.Node) extends TheDiff {
-  override def toString = s"""NodeNotFound(
-      |   ${node}
-      |)""".stripMargin
-}
+  case class NodeDiff(path: List[xml.Node], expected: xml.Node, actual: xml.Node) extends XmlDiff {
+    override def toString = s"""NodeDiff(
+                                |   Expected: ${expected}
+                                |   Actual: ${actual}
+                                |)""".stripMargin
+  }
 
-case class NodeDiff(path: List[xml.Node], expected: xml.Node, actual: xml.Node) extends TheDiff {
-  override def toString = s"""NodeDiff(
-      |   Expected: ${expected}
-      |   Found: ${actual}
-      |)""".stripMargin
-}
+  case class AttributesDiff(path: List[xml.Node], expected: xml.MetaData, actual: xml.MetaData) extends XmlDiff {
+    override def toString = s"""AttributesDiff(
+                                |   Expected: ${expected.asAttrMap}
+                                |   Actual: ${actual.asAttrMap}
+                                |)""".stripMargin
+  }
 
-case class AttributesDiff(path: List[xml.Node], expected: xml.MetaData, actual: xml.MetaData) extends TheDiff {
-  override def toString = s"""AttributesDiff(
-      |   Expected: ${expected.asAttrMap}
-      |   Found: ${actual.asAttrMap}
-      |)""".stripMargin
-}
+  case class ChildrenDiff(path: List[xml.Node], element: xml.Node, list: List[XmlDiff]) extends XmlDiff {
+    override def toString = {
+      val wrongElementsReport = list.mkString(",\n").lines.map("   " + _).mkString("\n")
+      s"""ChildrenDiff(
+          |   None of the elements found fully matched $element
+          |$wrongElementsReport
+          |)""".stripMargin
+    }
+  }
 
-case class ChildrenDiff(path: List[xml.Node], element: xml.Node, list: List[XmlDiff]) extends TheDiff {
-  override def toString = s"""ChildrenDiff(
-      |   None of the elements found fully matched ${element}
-      |${list.mkString(",\n").lines.map("   " + _).mkString("\n")}
-      |)""".stripMargin
-}
+}

src/main/scala/com/github/andyglow/xml/diff/XmlPath.scala

@@ -17,43 +17,74 @@
  */
 package com.github.andyglow.xml.diff
 
-case class XmlPath(elems: List[String]) {
-
-  /** Returns true if this XPath matches the given path. */
-  def matches(other: List[String]): Boolean = {
-    var xs = elems
-    var ys = other
-    
-    while (ys != Nil && xs != Nil) {
-      if (xs.head == XmlPath.WILDCARD) {
-        // skip any number of non-matching elements from 'other'
-        while (ys != Nil && xs.tail.head != ys.head) ys = ys.tail
-        xs = xs.tail
-      } else if (xs.head == ys.head) {
-          xs = xs.tail
-          ys = ys.tail
-      } else
-        return false
-    }
-    xs == Nil
-  }
-  
-  override def toString = elems.mkString("", "/", "")
+sealed trait XmlPath {
+  def head: XmlPath.NameMatcher
+  def tail: XmlPath
+  def isEmpty: Boolean
+  def matches(path: List[String]): Boolean
+  def ::(head: XmlPath.NameMatcher) = XmlPath.::(head, this)
 }
 
 object XmlPath {
 
-  def apply(path: String): XmlPath = XmlPath(parse(path))
+  sealed trait NameMatcher extends (String => Boolean)
+  object NameMatcher {
+    case object Wildcard extends NameMatcher {
+      def apply(x: String): Boolean = true
+      override def toString: String = "*"
+    }
+    case class Text(name: String) extends NameMatcher {
+      def apply(x: String): Boolean = x == name
+      override def toString: String = name
+    }
+    def apply(text: String): NameMatcher = text.trim match {
+      case "*" => Wildcard
+      case x => Text(x)
+    }
+  }
 
-  val WILDCARD = "*"
+  case object Nil extends XmlPath {
+    override def isEmpty: Boolean = true
+    override def head: NameMatcher = throw new NoSuchElementException("head of empty xml path")
+    override def tail: XmlPath = throw new UnsupportedOperationException("tail of empty xml path")
+    override def equals(that: Any) = that.isInstanceOf[Nil.type]
+    override def matches(path: List[String]): Boolean = path.isEmpty
+    override def toString: String = ""
+  }
 
-  private def parse(path: String): List[String] = path.split('/')
-    .map(_.trim)
-    .filter(!_.isEmpty)
-    // remove duplicated *
-    .foldRight(Nil: List[String]) {(token, list) => list match {
-      case h :: t if h == WILDCARD && token == WILDCARD => list
-      case _ => token :: list
-    }}
+  case class ::(head: NameMatcher, tail: XmlPath) extends XmlPath {
+    override def toString: String = tail.toString match {
+      case "" => head.toString()
+      case x => head + "/" + x
+    }
+    override def isEmpty: Boolean = false
+    override def matches(path: List[String]): Boolean = {
+      def tokenMatches(thatHead: String): (Boolean, List[String]) = head match {
+        case NameMatcher.Wildcard if !tail.isEmpty  => (true, path.dropWhile(!tail.head(_)))
+        case NameMatcher.Wildcard                   => (true, scala.Nil)
+        case NameMatcher.Text(thisHead)             => (thatHead equals thisHead, path.tail)
+      }
 
-}
+      val matches = for {
+        thatHead            <- path.headOption
+        (headMatches, rest) = tokenMatches(thatHead) if headMatches
+        result              = tail.matches(rest)
+      } yield result
+
+      matches getOrElse false
+    }
+  }
+
+  def apply(path: String): XmlPath = parse(path)
+
+  private def parse(path: String): XmlPath =
+    path
+      .split('/')
+      .map(_.trim)
+      .filter(!_.isEmpty)
+      .foldRight(Nil: XmlPath) { (token, list) => list match { // remove duplicated *
+        case h :: t if h == NameMatcher.Wildcard && token == "*" => list
+        case _ => NameMatcher(token) :: list
+      }}
+
+}

src/main/scala/com/github/andyglow/xml/diff/package.scala

@@ -20,7 +20,7 @@ package com.github.andyglow.xml
 package object diff {
 
   implicit class XmlOps(val x: xml.Elem) extends AnyVal {
-    def compareTo(o: xml.Elem): XmlDiff = XmlComparator().compare(x, o)
+    def compareTo(o: xml.Elem): XmlDiffResult = XmlComparator().compare(x, o)
   }
 
 }