XML-Viewer

// Print the shape of a document: element paths with a count, which is
// usually more useful than the tree itself when you are writing a consumer.
function outline(source) {
  const doc = new DOMParser().parseFromString(source, 'application/xml');
  const error = doc.querySelector('parsererror');
  if (error) throw new Error(error.textContent.trim());

  const counts = new Map();
  const walk = (el, path) => {
    const here = path + '/' + el.nodeName;
    counts.set(here, (counts.get(here) ?? 0) + 1);
    for (const child of el.children) walk(child, here);
  };
  walk(doc.documentElement, '');

  for (const [path, n] of [...counts].sort()) {
    console.log(n.toString().padStart(6), path);
  }
}

// nodeName keeps the prefix as written. For namespace-aware work use
// el.localName with el.namespaceURI, since the prefix is arbitrary and the
// URI is what identifies the vocabulary.

# iterparse reads the document as a stream and lets you drop each element
# once you are done with it, so memory stays flat on files far larger than a
# browser will open.
from defusedxml.ElementTree import iterparse
from collections import Counter

counts = Counter()
stack = []

for event, el in iterparse('document.xml', events=('start', 'end')):
    if event == 'start':
        stack.append(el.tag)
        counts['/'.join(stack)] += 1
    else:
        stack.pop()
        el.clear()          # release the subtree; this is the whole point

for path, n in sorted(counts.items()):
    print(f'{n:6d}  {path}')

# ElementTree reports tags as '{namespace-uri}local' rather than 'prefix:local'
# because the prefix is arbitrary. Split on '}' when you want the local name.

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;

public final class Outline {

    public static void main(String[] args) throws Exception {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);                 // off by default
        dbf.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
        dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        dbf.setXIncludeAware(false);

        Document doc = dbf.newDocumentBuilder().parse(new java.io.File(args[0]));
        print(doc.getDocumentElement(), 0);
    }

    static void print(Node node, int depth) {
        if (node.getNodeType() != Node.ELEMENT_NODE) return;
        Element el = (Element) node;

        StringBuilder line = new StringBuilder("  ".repeat(depth));
        line.append(el.getNodeName());
        NamedNodeMap attrs = el.getAttributes();
        for (int i = 0; i < attrs.getLength(); i++) {
            Node a = attrs.item(i);
            line.append(' ').append(a.getNodeName())
                .append("=\"").append(a.getNodeValue()).append('"');
        }
        System.out.println(line);

        NodeList kids = el.getChildNodes();
        for (int i = 0; i < kids.getLength(); i++) print(kids.item(i), depth + 1);
    }
}

using System.Xml;
using System.Xml.Linq;

// XDocument.Load uses a reader with DtdProcessing.Prohibit by default, so
// external entities are never fetched. Construct the reader yourself when
// you want that guarantee stated in the code rather than in the docs.
var settings = new XmlReaderSettings
{
    DtdProcessing = DtdProcessing.Prohibit,
    XmlResolver = null,
    MaxCharactersInDocument = 20L * 1024 * 1024,
};

using var reader = XmlReader.Create("document.xml", settings);
var doc = XDocument.Load(reader);

// One line per distinct element path, with how often it occurs.
var paths = doc.Descendants()
    .GroupBy(e => string.Join(
        "/",
        e.AncestorsAndSelf().Reverse().Select(a => a.Name.LocalName)))
    .OrderBy(g => g.Key);

foreach (var group in paths)
{
    Console.WriteLine(group.Count().ToString().PadLeft(6) + "  " + group.Key);
}

# xmllint has an interactive tree browser almost nobody knows about. It gives
# you ls, cd, cat, du and pwd over the document, with XPath as the path
# syntax: the terminal equivalent of the tree on this page.
xmllint --nonet --shell document.xml
#   / > du                      show the subtree shape
#   / > cd //order[1]           navigate by XPath
#   / > ls                      list children of the current node
#   / > cat status              print a node
#   / > exit

# Non-interactive: tag counts, a rough outline of an unfamiliar document.
xmllint --nonet --format document.xml |
  grep -o '<[a-zA-Z_][^ />]*' |
  sort | uniq -c | sort -rn | head -30

# One value, straight out:
xmllint --nonet --xpath 'string(//order[1]/status)' document.xml