Piuttosto stampare file XML su Emacs

Uso emacs per modificare i miei file xml (modalità nxml) ei file sono stati generati dalla macchina non hanno alcuna formattazione carina dei tag.

Ho cercato di stampare abbastanza l'intero file con rientro e salvarlo, ma non sono riuscito a trovare un modo automatico.

C'è un modo? O almeno qualche editor su Linux che può farlo.

Uso la modalità nXML per l'editing e Tidy quando voglio formattare e indentare XML o HTML. C'è anche un'interfaccia Emacs per Tidy.

Non hai nemmeno bisogno di scrivere la tua funzione - sgml-mode (un modulo principale di gnu emacs) ha una funzione di stampa graziosa incorporata chiamata (sgml-pretty-print ...) che accetta gli argomenti di inizio e fine della regione.

Se stai tagliando e incollando xml e trovi che il tuo terminale sta tagliando le linee in posti arbitrari, puoi usare questa bella stampante che corregge prima le linee interrotte.

Se hai solo bisogno di un bel rientro senza introdurre nuove interruzioni di riga, puoi applicare il indent-regioncomando all'intero buffer con queste sequenze di tasti:

C-x h
C-M-\

Se hai anche bisogno di introdurre interruzioni di riga, in modo che i tag di apertura e chiusura siano su righe separate, potresti usare la seguente funzione elisp molto carina, scritta da Benjamin Ferrari . L'ho trovato sul suo blog e spero che mi vada bene riprodurlo qui:

(defun bf-pretty-print-xml-region (begin end)
  "Pretty format XML markup in region. You need to have nxml-mode
http://www.emacswiki.org/cgi-bin/wiki/NxmlMode installed to do
this.  The function inserts linebreaks to separate tags that have
nothing but whitespace between them.  It then indents the markup
by using nxml's indentation rules."
  (interactive "r")
  (save-excursion
    (nxml-mode)
    (goto-char begin)
    (while (search-forward-regexp "\>[ \\t]*\<" nil t) 
      (backward-char) (insert "\n") (setq end (1+ end)))
    (indent-region begin end))
  (message "Ah, much better!"))

Questo non si basa su uno strumento esterno come Tidy.

Emacs può eseguire comandi arbitrari con M- |. Se hai xmllint installato:

"M- | xmllint --format -" formatterà la regione selezionata

"Cu M- | xmllint --format -" farà lo stesso, sostituendo la regione con l'output

Grazie a Tim Helmstedt sopra ho fatto st così:

(defun nxml-pretty-format ()
    (interactive)
    (save-excursion
        (shell-command-on-region (point-min) (point-max) "xmllint --format -" (buffer-name) t)
        (nxml-mode)
        (indent-region begin end)))

veloce e facile. Grazie molto.

Per introdurre interruzioni di riga e quindi stampare in modo carino

M-x sgml-mode
M-x sgml-pretty-print

ecco alcune modifiche che ho apportato alla versione di Benjamin Ferrari:

• il search-forward-regexpnon ha specificato una fine, quindi avrebbe operato su cose dall'inizio della regione alla fine del buffer (invece che alla fine della regione)
• Ora aumenta endcorrettamente, come ha notato Cheeso.
• inserirà un'interruzione tra <tag></tag>, che ne modifica il valore. Sì, tecnicamente stiamo modificando i valori di tutto qui, ma è molto più probabile che un inizio / fine vuoto sia significativo. Ora utilizza due ricerche separate, leggermente più rigorose per evitarlo.

Ha ancora "non si basa sull'ordinamento esterno", ecc. Tuttavia, richiede clla incfmacro.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; pretty print xml region
(defun pretty-print-xml-region (begin end)
  "Pretty format XML markup in region. You need to have nxml-mode
http://www.emacswiki.org/cgi-bin/wiki/NxmlMode installed to do
this.  The function inserts linebreaks to separate tags that have
nothing but whitespace between them.  It then indents the markup
by using nxml's indentation rules."
  (interactive "r")
  (save-excursion
    (nxml-mode)
    (goto-char begin)
    ;; split <foo><foo> or </foo><foo>, but not <foo></foo>
    (while (search-forward-regexp ">[ \t]*<[^/]" end t)
      (backward-char 2) (insert "\n") (incf end))
    ;; split <foo/></foo> and </foo></foo>
    (goto-char begin)
    (while (search-forward-regexp "<.*?/.*?>[ \t]*<" end t)
      (backward-char) (insert "\n") (incf end))
    (indent-region begin end nil)
    (normal-mode))
  (message "All indented!"))

Un modo per farlo è se hai qualcosa nel formato seguente

<abc>     <abc><abc>   <abc></abc> </abc></abc>       </abc>

In Emacs, prova

M-x nxml-mode
M-x replace-regexp RET  > *< RET >C-q C-j< RET 
C-M-\ to indent

Questo farà rientrare l'esempio xml sopra a sotto

<abc>
  <abc>
    <abc>
      <abc>
      </abc>
    </abc>
  </abc>
</abc>

In VIM puoi farlo da

:set ft=xml
:%s/>\s*</>\r</g
ggVG=

Spero che sia di aiuto.

1. La modalità nxml di Emacs può funzionare sul formato presentato, ma dovrai dividere le linee.
2. Per file più lunghi che semplicemente non ne vale la pena. Esegui questo foglio di stile (idealmente con Saxon di cui IMHO ottiene i rientri di riga a destra) su file più lunghi per ottenere una bella stampa. Per tutti gli elementi in cui si desidera mantenere lo spazio bianco, aggiungere i loro nomi accanto a 'programlisting' come in 'programlisting yourElementName'

HTH

Ho preso la versione di Jason Viers e ho aggiunto la logica per inserire le dichiarazioni xmlns sulle loro linee. Questo presume che tu abbia xmlns = e xmlns: senza spazi bianchi intermedi.

(defun cheeso-pretty-print-xml-region (begin end)
  "Pretty format XML markup in region. You need to have nxml-mode
http://www.emacswiki.org/cgi-bin/wiki/NxmlMode installed to do
this.  The function inserts linebreaks to separate tags that have
nothing but whitespace between them.  It then indents the markup
by using nxml's indentation rules."
  (interactive "r")
  (save-excursion
    (nxml-mode)
    ;; split <foo><bar> or </foo><bar>, but not <foo></foo>
    (goto-char begin)
    (while (search-forward-regexp ">[ \t]*<[^/]" end t)
      (backward-char 2) (insert "\n") (incf end))
    ;; split <foo/></foo> and </foo></foo>
    (goto-char begin)
    (while (search-forward-regexp "<.*?/.*?>[ \t]*<" end t)
      (backward-char) (insert "\n") (incf end))
    ;; put xml namespace decls on newline
    (goto-char begin)
    (while (search-forward-regexp "\\(<\\([a-zA-Z][-:A-Za-z0-9]*\\)\\|['\"]\\) \\(xmlns[=:]\\)" end t)
      (goto-char (match-end 0))
      (backward-char 6) (insert "\n") (incf end))
    (indent-region begin end nil)
    (normal-mode))
  (message "All indented!"))

Tidy sembra una buona modalità. Devo guardarlo. Lo userò se avrò davvero bisogno di tutte le funzionalità che offre.

Ad ogni modo, questo problema mi ha tormentato per circa una settimana e non stavo cercando correttamente. Dopo aver pubblicato, ho iniziato a cercare e ho trovato un sito con una funzione elisp che lo fa abbastanza bene. L'autore suggerisce anche di utilizzare Tidy.

Grazie per la risposta Marcel (peccato non ho abbastanza punti per migliorarti) .

Ne posterò presto sul mio blog. Ecco un post a riguardo (con un collegamento al sito di Marcel).

Uso xml-reformat-tagsda xml-parse.el . Di solito vorrai avere il punto all'inizio del file quando esegui questo comando.

È interessante che il file sia incorporato in Emacspeak . Quando stavo usando Emacspeak giorno per giorno, pensavo xml-reformat-tagsfosse un Emacs integrato. Un giorno l'ho perso e ho dovuto fare una ricerca su Internet, quindi sono entrato nella pagina wiki sopra menzionata.

Allego anche il mio codice per avviare xml-parse. Non sono sicuro che questo sia il miglior pezzo di codice Emacs, ma sembra funzionare per me.

(if (file-exists-p "~/.emacs.d/packages/xml-parse.el")
  (let ((load-path load-path))
    (add-to-list 'load-path "~/.emacs.d/packages")
    (require 'xml-parse))
)

Se usi spacemacs , usa semplicemente il comando 'spacemacs / indent-region-or-buffer'.

M-x spacemacs/indent-region-or-buffer

dal 2017 emacs è già dotato di questa funzionalità di default, ma devi scrivere questa piccola funzione nel tuo ~/.emacs.d/init.el:

(require 'sgml-mode)

(defun reformat-xml ()
  (interactive)
  (save-excursion
    (sgml-pretty-print (point-min) (point-max))
    (indent-region (point-min) (point-max))))

quindi chiama M-x reformat-xml

fonte: https://davidcapello.com/blog/emacs/reformat-xml-on-emacs/

Temo che la versione di Benjamin Ferrari mi piaccia molto di più. La bella stampa interna posiziona sempre il tag di fine in una nuova riga dopo il valore, inserendo CR indesiderato nei valori del tag.