Scala: Ändern eines NodeSeq

Question

Ich habe eine NodeSeq wie folgt aus:

<foo>
<baz><bar key1="value1" key2="value2">foobar</bar></baz>
Blah blah blah
<bar key1="value3">barfoo</bar>
</foo>

Ich möchte Attribute ein neues Attribut auf alle bar s hinzuzufügen. Ich mache gerade:

Aber das Problem ist, dass es nur auf 1 Knoten funktioniert. Ich möchte es rekursiv auf allen Knoten arbeiten, und wenn ich die Transformation innerhalb einer for-Schleife aufrufen, kann ich sie nicht durch neue Werte ersetzen, da sie unveränderlich werden. Wie kann ich das lösen?

Answer 1

ist eine vereinfachte Version Ihrer eigenen Lösung (Daniels Variante der Anpassungslogik):

def updateBar(node: Node): Node = node match { 
    case elem @ Elem(_, "bar", _, _, child @ _*) => elem.asInstanceOf[Elem] % Attribute(None, "newKey", Text("newValue"), Null) copy(child = child map updateBar) 
    case elem @ Elem(_, _, _, _, child @ _*) => elem.asInstanceOf[Elem].copy(child = child map updateBar) 
    case other => other 
} 

Beachten Sie, dass die großen Unterschiede zwischen diesem und Ihrem ursprünglichen Code ist, dass dies ein Knoten aus den Prozessen außerhalb in, wie hier gezeigt, wo ich einige print-Anweisungen hinzugefügt habe, wie in meiner ersten Antwort:

scala> updateBar(<foo><bar>blabla</bar></foo>) 
processing '<foo><bar>blabla</bar></foo>' 
processing '<bar>blabla</bar>' 
processing 'blabla' 
result: 'blabla' 
result: '<bar newKey="newValue">blabla</bar>' 
result: '<foo><bar newKey="newValue">blabla</bar></foo>' 
res1: scala.xml.Node = <foo><bar newKey="newValue">blabla</bar></foo> 

Während Ihr ursprünglicher Code funktioniert vom innen nach außen (vereinfachtes Beispiel):

scala> xf { <a><b><c/></b></a> } 
transforming '<c></c>' 
result: '<c></c>' 
transforming '<b><c></c></b>' 
result: '<b><c></c></b>' 
transforming '<a><b><c></c></b></a>' 
result: '<a><b><c></c></b></a>' 
res4: scala.xml.Node = <a><b><c></c></b></a> 

Es gibt wahrscheinlich Fälle, in denen diese beiden Techniken zu unterschiedlichen Ergebnissen führen wird.

Der andere Unterschied ist, dass der übereinstimmende Code etwas ausführlicher ist: Sie benötigen einen Fall für die tatsächliche Transformation des relevanten Elements und einen Fall für die rekursive Verarbeitung der Unterknoten. Das gezeigte Beispiel könnte allerdings etwas umgestaltet werden.

Answer 2

Das Bad Boy hat den Job:

def updateVersion(node : Node) : Node = node match { 
     case <foo>{ ch @ _* }</foo> => <foo>{ ch.map(updateVersion)}</foo> 
     case <baz>{ ch @ _* }</baz> => <baz>{ ch.map(updateVersion) }</baz> 
     case Elem(prefix, "bar", attribs, scope, content@_*) => Elem(prefix, "bar", attribs append Attribute(None, "key3", Text("value3"), scala.xml.Null) , scope, content:_*) 
     case other @ _ => other 
     } 

Answer 3

Versuchen

val rule = new RewriteRule() { 
    override def transform(node: Node): Seq[Node] = { 
     node match { 
      case elem : Elem if elem.label == "bar" => 
       (elem copy (child = this transform child)) % Attribute(None, "newKey", Text("newValue"), scala.xml.Null) 
      case elem : Elem => elem copy (child = this transform child) 
      case other => other 
     } 
    } 
    } 

Answer 4

Ihr Original-Code korrekt zu sein scheint. Das Problem ist nicht, dass es nicht rekursiv funktioniert (es tut), sondern ein seltsames Problem, das auftritt, wenn es genau ein vorhandenes Attribut gibt.

Blick auf die folgenden, die im Wesentlichen identisch mit Ihrem Code ist außer ich einige print-Anweisungen für das Debuggen hinzugefügt haben:

val rule = new RewriteRule() { 
    override def transform(node: Node): Seq[Node] = { 
     println("transforming '" + node + "'") 
     val result = node match { 
      case elem @ Elem(prefix, label @ "bar", attribs, scope, children @ _*) => 
       Elem(prefix, label, attribs append Attribute(None, "newKey", Text("newValue"), Null), scope, children: _*)   
      case other => other 
     } 
     println("result: '" + result + "'") 
     result 
    } 
} 

object xf extends RuleTransformer(rule) 

Jetzt haben wir es testen:

scala> xf { <bar/> } 
transforming '<bar></bar>' 
result: '<bar newKey="newValue"></bar>' 
transforming '<bar></bar>' 
result: '<bar newKey="newValue"></bar>' 
res0: scala.xml.Node = <bar newKey="newValue"></bar> 

Wir sehen, dass für Bei einem Element ohne Attribute führt die Transformation dazu, dass das neue Attribut hinzugefügt wird und das zurückgegebene Ergebnis ebenfalls korrekt ist. (Ich weiß nicht, warum die Transformation zweimal auftritt.)

Wenn es jedoch ein existierendes Attribut:

scala> xf { <bar key1="value1"/> } 
transforming '<bar key1="value1"></bar>' 
result: '<bar key1="value1" newKey="newValue"></bar>' 
res1: scala.xml.Node = <bar key1="value1"></bar> 

Das Ergebnis der Transformation korrekt ist, aber es wird auf den letzten nicht weitergegeben Ergebnis!

Aber wenn es zwei (oder mehr) vorhandene Attribute ist, ist alles in Ordnung:

scala> xf { <bar key1="value1" key2="value2"/> } 
transforming '<bar key1="value1" key2="value2"></bar>' 
result: '<bar key2="value2" key1="value1" newKey="newValue"></bar>' 
transforming '<bar key1="value1" key2="value2"></bar>' 
result: '<bar key2="value2" key1="value1" newKey="newValue"></bar>' 
res2: scala.xml.Node = <bar key2="value2" key1="value1" newKey="newValue"></bar> 

Ich bin versucht zu glauben, dies ein Fehler in der Bibliothek ist.Hier