Al hacer scripts de shell, generalmente los datos estarán en archivos de registros de una sola línea como csv. Es realmente sencillo manejar estos datos con grepy sed. Pero tengo que lidiar con XML a menudo, por lo que realmente me gustaría una forma de acceso de script a esos datos XML a través de la línea de comandos. ¿Cuáles son las mejores herramientas?

He encontrado que xmlstarlet es bastante bueno en este tipo de cosas.

http://xmlstar.sourceforge.net/

También debería estar disponible en la mayoría de los repositorios de distro. Un tutorial introductorio está aquí:

http://www.ibm.com/developerworks/library/x-starlet.html

Algunas herramientas prometedoras:

• nokogiri : análisis de DOMs HTML / XML en ruby ​​usando selectores XPath y CSS

• hpricot : en desuso

• fxgrep : utiliza su propia sintaxis similar a XPath para consultar documentos. Escrito en SML, por lo que la instalación puede ser difícil.

• LT XML : XML Toolkit derivado de SGML, incluyendo herramientas sggrep, sgsort, xmlnormy otros. Utiliza su propia sintaxis de consulta. La documentación es muy formal. Escrito en C. LT XML 2 reclama el soporte de XPath, XInclude y otros estándares W3C.

• xmlgrep2 : búsqueda simple y potente con XPath. Escrito en Perl usando XML :: LibXML y libxml2.

• XQSharp : admite XQuery, la extensión de XPath. Escrito para .NET Framework.

• xml-coreutils : kit de herramientas de Laird Breyer equivalente a GNU coreutils. Discutido en un interesante ensayo sobre lo que debe incluir el conjunto de herramientas ideal.

• xmldiff : herramienta simple para comparar dos archivos xml.

• xmltk : no parece tener un paquete en debian, ubuntu, fedora o macports, no ha tenido un lanzamiento desde 2007 y utiliza la automatización de compilación no portátil.

xml-coreutils parece el mejor documentado y más orientado a UNIX.

A la excelente lista de Joseph Holsten, agrego el script de línea de comandos xpath que viene con la biblioteca Perl XML :: XPath. Una excelente manera de extraer información de archivos XML:

 xpath -q -e '/entry[@xml:lang="fr"]' *xml

También hay xml2y 2xmlpar. Permitirá que las herramientas habituales de edición de cadenas procesen XML.

Ejemplo. q.xml:

<?xml version="1.0"?>
<foo>
    text
    more text
    <textnode>ddd</textnode><textnode a="bv">dsss</textnode>
    <![CDATA[ asfdasdsa <foo> sdfsdfdsf <bar> ]]>
</foo>

xml2 < q.xml

/foo=
/foo=   text
/foo=   more text
/foo=   
/foo/textnode=ddd
/foo/textnode
/foo/textnode/@a=bv
/foo/textnode=dsss
/foo=
/foo=    asfdasdsa <foo> sdfsdfdsf <bar> 
/foo=

xml2 < q.xml | grep textnode | sed 's!/foo!/bar/baz!' | 2xml

<bar><baz><textnode>ddd</textnode><textnode a="bv">dsss</textnode></baz></bar>

PD También hay html2/ 2html.

Puedes usar xmllint:

xmllint --xpath //title books.xml

Debe incluirse con la mayoría de las distribuciones, y también incluye Cygwin.

$ xmllint --version
xmllint: using libxml version 20900

Ver:

$ xmllint
Usage : xmllint [options] XMLfiles ...
        Parse the XML files and output the result of the parsing
        --version : display the version of the XML library used
        --debug : dump a debug tree of the in-memory document
        ...
        --schematron schema : do validation against a schematron
        --sax1: use the old SAX1 interfaces for processing
        --sax: do not build a tree but work just at the SAX level
        --oldxml10: use XML-1.0 parsing rules before the 5th edition
        --xpath expr: evaluate the XPath expression, inply --noout

Si está buscando una solución en Windows, Powershell tiene una funcionalidad incorporada para leer y escribir XML.

test.xml:

<root>
  <one>I like applesauce</one>
  <two>You sure bet I do!</two>
</root>

Script de Powershell:

# load XML file into local variable and cast as XML type.
$doc = [xml](Get-Content ./test.xml)

$doc.root.one                                   #echoes "I like applesauce"
$doc.root.one = "Who doesn't like applesauce?"  #replace inner text of <one> node

# create new node...
$newNode = $doc.CreateElement("three")
$newNode.set_InnerText("And don't you forget it!")

# ...and position it in the hierarchy
$doc.root.AppendChild($newNode)

# write results to disk
$doc.save("./testNew.xml")

testNew.xml:

<root>
  <one>Who likes applesauce?</one>
  <two>You sure bet I do!</two>
  <three>And don't you forget it!</three>
</root>

Fuente: /server/26976/update-xml-from-the-command-line-windows

¡También hay xmlsed y xmlgrep de NetBSD xmltools!

http://blog.huoc.org/xmltools-not-dead.html

Depende exactamente de lo que quieras hacer.

XSLT puede ser el camino a seguir, pero hay una curva de aprendizaje. Pruebe xsltproc y tenga en cuenta que puede entregar los parámetros.

También hay una saxon-lintlínea de comandos con la capacidad de usar XPath 3.0 / XQuery 3.0. (Otras herramientas de línea de comandos usan XPath 1.0).

EJEMPLOS

http / html:

$ saxon-lint --html --xpath 'count(//a)' http://stackoverflow.com/q/91791
328

xml:

$ saxon-lint --xpath '//a[@class="x"]' file.xml

D. Bohdan mantiene un repositorio de código abierto de GitHub que mantiene una lista de herramientas de línea de comandos para herramientas de texto estructurado, hay una sección para herramientas XML / HTML:

https://github.com/dbohdan/structured-text-tools#xml-html

XQuery podría ser una buena solución. Es (relativamente) fácil de aprender y es un estándar W3C.

Recomendaría XQSharp para un procesador de línea de comando.

Primero usé xmlstarlet y todavía lo uso. Cuando la consulta se vuelve difícil, necesito el soporte de las funciones xpath2 y xquery de XML. Me dirijo a xidel http://www.videlibri.de/xidel.html

Grep equivalente

Puede definir una función bash, digamos "xp" ("xpath") que envuelve algún código python3. Para usarlo necesitas instalar python3 y python-lxml. Beneficios:

1. coincidencia de expresiones regulares que le falta, por ejemplo, en xmllint.
2. Usar como filtro (en una tubería) en la línea de comando

Es fácil y poderoso de usar así:

xmldoc=$(cat <<EOF
<?xml version="1.0" encoding="utf-8"?>
<job xmlns="http://www.sample.com/">programming</job>
EOF
)
selection='//*[namespace-uri()="http://www.sample.com/" and local-name()="job" and re:test(.,"^pro.*ing$")]/text()'
echo "$xmldoc" | xp "$selection"
# prints programming

xp () se parece a esto:

xp()
{ 
local selection="$1";
local xmldoc;
if ! [[ -t 0 ]]; then
    read -rd '' xmldoc;
else
    xmldoc="$2";
fi;
python3 <(printf '%b' "from lxml.html import tostring\nfrom lxml import etree\nfrom sys import stdin\nregexpNS = \"http://exslt.org/regular-expressions\"\ntree = etree.parse(stdin)\nfor e in tree.xpath('""$selection""', namespaces={'re':regexpNS}):\n  if isinstance(e, str):\n    print(e)\n  else:\n    print(tostring(e).decode('UTF-8'))") <<< "$xmldoc"
}

Equivalente de Sed

Considere usar xq que le brinda todo el poder del "lenguaje de programación" jq. Si tiene instalado python-pip, puede instalar xq con pip install yq , luego, en el siguiente ejemplo, reemplazaremos "Mantener cuentas" por "Mantener cuentas 2":

xmldoc=$(cat <<'EOF'
<resources>
    <string name="app_name">Keep Accounts</string>
    <string name="login">"login"</string>
    <string name="login_password">"password："</string>
    <string name="login_account_hint">input to login</string>
    <string name="login_password_hint">input your password</string>
    <string name="login_fail">login failed</string>
</resources>
EOF
)
echo "$xmldoc" | xq '.resources.string = ([.resources.string[]|select(."#text" == "Keep Accounts") ."#text" = "Keep Accounts 2"])' -x

JEdit tiene un complemento llamado "XQuery" que proporciona funcionalidad de consulta para documentos XML.

No es exactamente la línea de comando, ¡pero funciona!