how to sort JsArrays with play-json - json

Question

simple question:
How can one use play-json (2.3.x) to sort all JsArrays in some JsValue (recursively)?
my usecase:
consider an app that uses Set[String] internally, and when data is requested,
the output JSON serialize the set as a JSON array. the order is not important.
now, if one wants to write some tests to cover this functionality, since the order of items is not important (it is a set after all. internally, and conceptually), and all I want to check is that everything returned as it should, I may want to compare the response JSON with an "expected" JSON object I create explicitly.
for that exact reason, I want to sort the JSON arrays, and compare the JsValue's.
how would one write such transformer?
EDIT:
I have managed to write a transformer that answers my needs, but it won't sort every JsArry in some JsValue. I'll post it here, since it might be useful for others, but it is not what I was asking for.
val jsonSortTransformer = (__ \ 'fields).json.update(
Reads.JsObjectReads.map{
case JsObject(xs) => JsObject(
xs.map{
case (n,jv) => {
n -> (jv match {
case JsArray(arr) if arr.forall(_.isInstanceOf[JsString]) => JsArray(arr.sortBy(_.as[String]))
case _ => jv
})
}
}
)
}
)

Answer 1

You can use the value property on JsArray to get a Seq[JsValue], then sort arbitrarily, and then recreate a JsArray. For example:
scala> myJsArray
play.api.libs.json.JsArray = ["11","4","5","1","22","2"]
scala> JsArray(myJsArray.value.sortBy(_.as[JsString].value.toInt))
play.api.libs.json.JsArray = ["1","2","4","5","11","22"]
If all you're doing is trying to compare actual and expected values of what you know is a set, you can also just use value on both properties, build a Set and check for equality:
Set(actual.value: _*) == Set(expected.value: _*)
Or sort them both:
val sortedSeq: JsArray => Seq[String] = array => array.value.map(_.toString).sorted
sortedSeq(actual) == sortedSeq(expected)
To recursively sort all the JsArrays in an arbitrary JsValue, it might look something like:
def sortArrays(json: JsValue): JsValue = json match {
case JsObject(obj) => JsObject(obj.toMap.mapValues(sortArrays(_)).toList)
case JsArray(arr) => JsArray(arr.map(sortArrays).sortBy(_.toString))
case other => other
}
scala> myObj
play.api.libs.json.JsValue = {"a":[2,1],"b":[{"c":[3,2]},{"d":[4,3]}],"e":{"f":[5,4]}}
scala> sortArrays(myObj)
play.api.libs.json.JsValue = {"a":[1,2],"b":[{"c":[2,3]},{"d":[3,4]}],"e":{"f":[4,5]}}

Answer 2

I'm afraid that #Ben's answer is quite incorrect.
I would approach this problem by defining an Ordering class for JsValues and then use its comparison method to verify equality (meaning this should actually be an object - not an anonymous class, as shown in the example).
One doesn't have to use Ordering, I just find it a bit more convenient than a simple compareTo method. Of course, one can also define this class/object as implicit.
val jsonOrdering: Ordering[JsValue] = new Ordering[JsValue]() {
override def compare(x: JsValue, y: JsValue): Int = {
x.getClass.getName.compareTo(y.getClass.getName) match {
case 0 =>
(x, y) match {
case (JsNull, JsNull) => 0
case (JsString(valueX), JsString(valueY)) =>
valueX.compareTo(valueY)
case (JsNumber(valueX), JsNumber(valueY)) =>
valueX.compare(valueY)
case (JsBoolean(boolX), JsBoolean(boolY)) =>
boolX.compareTo(boolY)
case (JsArray(elementsX), JsArray(elementsY)) =>
elementsX.size.compareTo(elementsY.size) match {
case 0 =>
elementsX
// .sorted(this) // uncomment if array order DOES NOT matter
.zip(elementsY
// .sorted(this) // uncomment if array order DOES NOT matter
)
.view
.map {
case (elementX, elementY) => compare(elementX, elementY)
}
.find(_ != 0)
.getOrElse(0)
case nonZero => nonZero
}
case (JsObject(fieldsX), JsObject(fieldsY)) =>
fieldsX.size.compareTo(fieldsY.size) match {
case 0 =>
fieldsX.toSeq
.sortBy(_._1)
.zip(fieldsY.toSeq.sortBy(_._1))
.view
.flatMap {
case ((keyX, valueX), (keyY, valueY)) =>
Seq(keyX.compareTo(keyY), compare(valueX, valueY))
}
.find(_ != 0)
.getOrElse(0)
case nonZero => nonZero
}
}
case nonZero => nonZero
}
}
I would perhaps split some parts into private/nested functions (I got lazy this time). Anyway, let's go over this:
Compare the two values' class names, and if they aren't the same then return the comparison between their names.
If the values are of any primitive JSON type, simply return the comparison between them.
If the values are arrays, then:
Compare their sizes, and if they aren't the same then return the comparison between the sizes.
Only if the order of arrays doesn't matter - sort each of the arrays (with the same ordering class; i.e, this is recursive).
Zip the elements of both arrays (so that you get an array of pairs of elements).
Find the first pair that its two elements are not the same, and return their comparison.
If no such pair exists, this means that the arrays are the same (return 0).
If the values are maps (objects):
Compare their sizes, and if they aren't the same then return the comparison between the sizes.
Turn the maps into a sequence of tuples, and sort these sequences by their key (first element of a tuple).
Zip the tuples of both sequences (so that you get an array of pairs of tuples).
Find the first pair that its tuples are not the same, and return their comparison. Compare these tuples in the following manner:
Compare their keys (strings), and return their comparison if they're not the same.
Compare their values (JsValue, thus using the same method recursively), and return their comparison if they're not the same.
Otherwise, they are the same.
If no such pair exists, this means that the maps (objects) are the same (return 0).
Note that although this ordering is consistent and deterministic, it is quite arbitrary and doesn't convey much logical meaning.