Ao executar scripts de shell, normalmente os dados estarão em arquivos de registros de linha única como o csv. É realmente simples manipular esses dados com grepe sed. Mas eu tenho que lidar com XML frequentemente, então eu realmente gostaria de uma maneira de criar um script de acesso a esses dados XML através da linha de comando. Quais são as melhores ferramentas?

Eu achei o xmlstarlet muito bom nesse tipo de coisa.

http://xmlstar.sourceforge.net/

Também deve estar disponível na maioria dos repositórios de distribuição. Um tutorial introdutório está aqui:

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

Algumas ferramentas promissoras:

• nokogiri : analisando DOMs HTML / XML em ruby ​​usando seletores XPath e CSS

• hpricot : descontinuado

• fxgrep : Usa sua própria sintaxe semelhante ao XPath para consultar documentos. Escrito em SML, a instalação pode ser difícil.

• LT XML : kit de ferramentas XML derivada de ferramentas SGML, incluindo sggrep, sgsort, xmlnorme outros. Usa sua própria sintaxe de consulta. A documentação é muito formal. Escrito em C. O LT XML 2 alega suporte ao XPath, XInclude e outros padrões W3C.

• xmlgrep2 : pesquisa simples e poderosa com o XPath. Escrito em Perl usando XML :: LibXML e libxml2.

• XQSharp : Suporta XQuery, a extensão para XPath. Escrito para o .NET Framework.

• xml-coreutils : kit de ferramentas do Laird Breyer equivalente ao GNU coreutils. Discutido em um ensaio interessante sobre o que o kit de ferramentas ideal deve incluir.

• xmldiff : ferramenta simples para comparar dois arquivos xml.

• xmltk : parece não ter pacote no debian, ubuntu, fedora ou macports, não é lançado desde 2007 e usa automação de compilação não portátil.

O xml-coreutils parece o melhor documentado e o mais orientado para UNIX.

À excelente lista de Joseph Holsten, adiciono o script de linha de comando xpath que acompanha a biblioteca Perl XML :: XPath. Uma ótima maneira de extrair informações de arquivos XML:

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

Há também xml2e 2xmlpar. Isso permitirá que as ferramentas comuns de edição de cadeias processem XML.

Exemplo. 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 Há também html2/ 2html.

Você pode usar xmllint:

xmllint --xpath //title books.xml

Deve ser fornecido com a maioria das distribuições e também com o Cygwin.

$ xmllint --version
xmllint: using libxml version 20900

Vejo:

$ 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 você está procurando uma solução no Windows, o Powershell possui uma funcionalidade integrada para ler e escrever XML.

test.xml:

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

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

Também há xmlsed e xmlgrep dos xmltools do NetBSD!

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

Depende exatamente do que você deseja fazer.

O XSLT pode ser o caminho a seguir, mas há uma curva de aprendizado. Tente xsltproc e observe que você pode entregar parâmetros.

Também existe na saxon-lintlinha de comando a capacidade de usar o XPath 3.0 / XQuery 3.0. (Outras ferramentas de linha de comando usam o XPath 1.0).

EXEMPLOS :

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 mantém um repositório de código-fonte aberto do GitHub que mantém uma lista de ferramentas de linha de comando para ferramentas de texto estruturado; há uma seção para ferramentas XML / HTML:

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

XQuery pode ser uma boa solução. É (relativamente) fácil de aprender e é um padrão W3C.

Eu recomendaria o XQSharp para um processador de linha de comando.

Eu usei o xmlstarlet pela primeira vez e ainda o uso. Quando a consulta fica difícil, preciso do suporte aos recursos xpath2 e xquery do XML. Volto- me para xidel http://www.videlibri.de/xidel.html

Equivalente Grep

Você pode definir uma função bash, digamos "xp" ("xpath") que envolve algum código python3. Para usá-lo, você precisa instalar python3 e python-lxml. Benefícios:

1. correspondência de regex que você não possui, por exemplo, xmllint.
2. Use como um filtro (em um canal) na linha de comando

É fácil e poderoso de usar assim:

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 com isso:

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 Equivalent

Considere o uso do xq, que fornece todo o poder da "linguagem de programação" jq. Se você possui o python-pip instalado, pode instalar o xq com o pip install yq ; no exemplo abaixo, estamos substituindo "Manter contas" por "Manter contas 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

O JEdit possui um plugin chamado "XQuery", que fornece funcionalidade de consulta para documentos XML.

Não é bem a linha de comando, mas funciona!