Quando si eseguono script di shell, in genere i dati si trovano in file di record a riga singola come CSV. È davvero semplice gestire questi dati con grepe sed. Ma devo occuparmi spesso di XML, quindi mi piacerebbe davvero un modo per accedere agli script di quei dati XML tramite la riga di comando. Quali sono gli strumenti migliori?

Ho trovato xmlstarlet per essere abbastanza bravo in questo genere di cose.

http://xmlstar.sourceforge.net/

Dovrebbe essere disponibile anche nella maggior parte dei repository di distro. Un tutorial introduttivo è qui:

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

Alcuni strumenti promettenti:

• nokogiri : analisi di DOM HTML / XML in ruby ​​utilizzando selettori XPath e CSS

• hpricot : deprecato

• fxgrep : utilizza la propria sintassi simile a XPath per eseguire query sui documenti. Scritto in SML, quindi l'installazione potrebbe essere difficile.

• LT XML : toolkit XML derivato da strumenti SGML, tra cui sggrep, sgsort, xmlnorme altri. Utilizza la propria sintassi della query. La documentazione è molto formale. Scritto in C. LT XML 2 rivendica il supporto di XPath, XInclude e altri standard W3C.

• xmlgrep2 : ricerca semplice e potente con XPath. Scritto in Perl usando XML :: LibXML e libxml2.

• XQSharp : supporta XQuery, l'estensione di XPath. Scritto per .NET Framework.

• xml-coreutils : toolkit di Laird Breyer equivalente ai coreutils GNU. Discusso in un saggio interessante su cosa dovrebbe includere il toolkit ideale.

• xmldiff : semplice strumento per confrontare due file xml.

• xmltk : non sembra avere un pacchetto in debian, ubuntu, fedora o macports, non è stato rilasciato dal 2007 e usa un'automazione di build non portatile.

xml-coreutils sembra il meglio documentato e orientato a UNIX.

All'eccellente elenco di Joseph Holsten, aggiungo lo script da riga di comando xpath fornito con la libreria Perl XML :: XPath. Un ottimo modo per estrarre informazioni dai file XML:

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

C'è anche xml2e 2xmlcoppia. Consentirà ai soliti strumenti di modifica delle stringhe di elaborare XML.

Esempio. 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>

PS Ci sono anche html2/ 2html.

Puoi usare xmllint:

xmllint --xpath //title books.xml

Dovrebbe essere in bundle con la maggior parte delle distro, ed è anche in bundle con Cygwin.

$ xmllint --version
xmllint: using libxml version 20900

Vedere:

$ 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

Se stai cercando una soluzione su Windows, Powershell ha funzionalità integrate per la lettura e la scrittura di XML.

test.xml:

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

Script 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>

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

Ci sono anche xmlsed e xmlgrep degli xmltools di NetBSD!

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

Dipende esattamente da cosa vuoi fare.

XSLT può essere la strada da percorrere, ma c'è una curva di apprendimento. Prova xsltproc e nota che puoi consegnare i parametri.

C'è anche saxon-lintdalla riga di comando con la possibilità di utilizzare XPath 3.0 / XQuery 3.0. (Altri strumenti da riga di comando utilizzano XPath 1.0).

ESEMPI:

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 repository GitHub open source che mantiene un elenco di strumenti da riga di comando per strumenti di testo strutturato, c'è una sezione per strumenti XML / HTML:

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

XQuery potrebbe essere una buona soluzione. È (relativamente) facile da imparare ed è uno standard W3C.

Consiglierei XQSharp per un processore da riga di comando.

Prima ho usato xmlstarlet e lo sto ancora usando. Quando la query diventa difficile, ho bisogno del supporto XML per xpath2 e xquery e mi rivolgo a xidel http://www.videlibri.de/xidel.html

Grep Equivalent

È possibile definire una funzione bash, dire "xp" ("xpath") che avvolge del codice python3. Per usarlo è necessario installare python3 e python-lxml. Benefici:

1. corrispondenza regex che manca ad es. xmllint.
2. Utilizzare come filtro (in una pipe) sulla riga di comando

È facile e potente da usare in questo modo:

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 () ha un aspetto simile al seguente:

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"
}

Sed equivalente

Prendi in considerazione l'uso di xq che ti dà tutta la potenza del "linguaggio di programmazione" jq. Se hai installato python-pip, puoi installare xq con pip install yq , quindi nell'esempio seguente sostituiamo "Mantieni account" con "Mantieni account 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 ha un plugin chiamato "XQuery" che fornisce funzionalità di interrogazione per documenti XML.

Non proprio la riga di comando, ma funziona!