Pattern matching with multiline XML case

Question

I must be doing some stupid mistake. I have a server that returns the XML <a><b>123</b></a> and now I would like to match against that XML. So I write something like

xml match {
  case <a><b>{_}</b></a> => true
}

This works as long as I do not have to deal with multi-line XML literals. So the important thing is that the server sends me the whole XML as a one-liner. The XML is large enough to explode a single line of code, but I can not figure out how to get this to work.

Server sends <a><b>123</b><c>123</c><d>123</d><e>123</e><f>123</f></a> and I would like to do this:

xml match {
  case <a>
    <b>{_}</b>
    <c>{valueOfC}</c>
    <d>{_}</d>
    <e>{_}</e>
    <f>{_}</f>
  </a> => valueOfC
}

But I always get a MatchError. If I write everything in a single line it works. So the question is: how can I match XML while writing human-readable code?

I have of course tried to find an answer via Google. Funny enough all examples are one-liners or work recursive.

Answer 1

XML with and without newlines and other whitespace is not considered the same using "match". If you use scala.xml.Utility.trim, you can remove whitespace. (You probably want to trim both your input and what the server gives you unless you're positive the server will send you no whitespace.)

Answer 2

Perhaps you could try something like:

x match {
  case <a><b>{n @ _*}</b></a> => println(n)
}

I'm not saying it will work... but it might

Answer 3

This is considerably uglier than I had initially imagined. I do have a partial solution, but I'm not sure it's worth the effort. The default pattern match treats whitespace as tokens, and I've not found any clean way to get around it. So I've done the opposite: decorate the input string with whitespace. This example has just a single level of indentation; you could imagine recursing the whitespace-addition to match your favorite indentation style.

Here's the example (need to compile and run; the 2.7 REPL at least doesn't seem to like multi-line XML in case statements).

object Test {

import scala.xml._

def whiten(xml: Node,w:String): Node = {
  val bits = Node.unapplySeq(xml)
  val white = new Text(w)
  val ab = new scala.collection.mutable.ArrayBuffer[Node]()
  ab += white;
  bits.get._3.foreach {b => ab += b ; ab += white }
  new Elem(
    xml.prefix,
    xml.label,
    xml.attributes,
    xml.scope,
    ab: _*
  );
}

val xml = <a><b>123</b><c>Works</c></a>

def main(args:Array[String]) {
  whiten(xml,"""
         """  // You must match the multiline whitespace to your case indentation!
  ) match { 
    case <a>
         <b>123</b>
         <c>{x}</c>
         </a> => println(x)
    case _ => println("Fails")
  }
}

}

Rather inelegant, but it does (marginally) achieve what you want.

Answer 4

Well, I don't have a solution to the match/case problem. You do need an extractor which whitens the input xml due to how Scala pattern matching works -- you cannot apply trim to an xml literal which is a pattern, as that exists just at compile time, patterns being translated into a series of function calls at runtime.

However, to get the value of the c tag, you could always use the XPath like syntax of taking xml apart. For example, to get the value of c in your XML you could use:

// a collection of all the values of all the c subelements (deep search)
val c1 = (xml \\ "c").map(_.text.toInt) 

// same as above, but shallow
val c2 = (xml \ "c").map(_.text.toInt)

Also see the XML chapter from Programming in Scala (part of which is on Google books)

Hope it helps,

-- Flaviu Cipcigan