Question

我试图编写一个XML解析实用程序，允许用户通过提供属性名称，当前属性值和他们希望该属性具有的新值来修改XML属性。这是我的代码：

def main (args: Array[String]) {
   val xml= <Rule debug="true" expression="testing"/>
   val printable= replaceXMLEntryAttribute(xml, "debug", "true", "false")
   println(printable)
}
/**
   * This method is used to iterate over the entirety of the xml presented and modify the XML attribute desired 
   */
  def replaceXMLEntryAttribute(elem: Elem, attrName: String, curVal: String, desiredVal: String): Elem = {

    def replace(current: Elem): Elem = current.copy(
      child = current.map {
        case e: Elem if isReplacementEntry(current, attrName, curVal) ⇒ generateReplacementXMLAttribute(current)
        case e: Elem ⇒ replace(e)
        case other⇒ other
      }
    )

   def generateReplacementXMLAttribute(node: Elem): Elem = {
      val currentXML= node.toString()
      val newAttr= currentXML.replace(curVal, desiredVal)
      return XML.loadString(newAttr)
    }
    replace(elem)
  }

  private def isReplacementEntry(node: Elem, attributeName: String,  currentAttrValue: String): Boolean = {
   val attr = "@" + attributeName
   val exists = node \\ attr find { _.text == currentAttrValue }
   exists match{
     case None => false
     case _ => true
   }

所需的输出为<Rule debug="false" expression="testing"/> 而该计划的结果是<Rule debug="true" expression="testing"><Rule expression="testing" debug="false"/></Rule>

我只能猜测并说替换方法在这里搞乱了。

Answer 1

Elem.map方法的文档没有任何文本可以解释它应该做什么，它的类型令人困惑。为了获得更具体的类型，我们可以使用Scala解释器：

scala> import scala.xml._
scala> val elem: Elem = <numbers><one/><two/><three/></numbers>
scala> :t elem.map(identity)
scala.xml.NodeSeq

奇怪，为什么它会产生NodeSeq？如果Elem.map映射到元素的子元素上，则返回具有相同标签和属性但新子元素的Elem，则返回类型应为Elem，而不是NodeSeq。为了验证Elem.map是否真正迭代其子节点，让我们将我们遇到的节点累积到列表中。

scala> var nodes = Seq[Node]()
scala> elem.map {node =>
     |   nodes :+= node
     |   node
     | }
res: scala.xml.NodeSeq = NodeSeq(<numbers><one/><two/><three/></numbers>)
scala> nodes
res: Seq[scala.xml.Node] = List(<numbers><one/><two/><three/></numbers>)

如果我们对孩子进行迭代，我会期待List(<one/>, <two/>, <three/>)，但那不是我们得到的。所以我们似乎正在迭代包含元素本身的1元素集合，这不是很有用。但是，查看the code，这似乎是有意的：Node，而Elem是NodeSeq的子类，其序列由单个元素本身组成。

因此，总而言之，您获得意外结果的原因是您从<Rule debug="true" expression="testing"/>开始，然后将其映射以获取结果<Rule debug="true" expression="testing"/>，然后将Rule的子项替换为结果，获得<Rule debug="true" expression="testing"><Rule expression="testing" debug="false"/></Rule>。

问题的这一部分的解决方案是使用current.child.map而不是current.map。但是，由于您只检查Rule的零子项而不是Rule本身，因此从不执行映射的主体，因此debug属性保持不变。我建议交换模式匹配和地图：

def replace: Node => Node =
  {
    case e: Elem if isReplacementEntry(e, attrName, curVal) ⇒ generateReplacementXMLAttribute(e)
    case e: Elem ⇒ e.copy(
      child = e.child.map { replace(_) }
    )
    case other⇒ other
  }

修复类型以使用Node而不是Elem后，我获得了所需的结果。

Answer 2

在github上检查我的库Advxml，以替换和编辑xml文档！

https://github.com/geirolz/advxml

示例：

import com.github.geirolz.advxml.all._
import scala.xml._
import scala.util._

//import MonadError instance for Try
import cats.instances.try_._

val doc: Elem = 
<Persons>
  <Person Name="Mimmo">
    <Cars>
      <Car Brand="Fiat"/>
    </Cars>
  </Person>
</Persons>

val rule: XmlRule = $(_ \ "Person" \ "Cars")
    ==> Replace(<Cars><Car Brand="Lamborghini"/></Cars>)

val result: Try[NodeSeq] = doc.transform[Try](rule)

Scala XML属性替换会导致将已修改的节点作为子节点附加

2 个答案: