Validateur de flux Atom

// Node 18 or later.  npm i @xmldom/xmldom
import { DOMParser } from '@xmldom/xmldom';

const ATOM = 'http://www.w3.org/2005/Atom';

// RFC 3339 as RFC 4287 section 3.3 requires it: uppercase T, uppercase Z.
const RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;

const xml = await (await fetch('https://example.com/atom.xml')).text();
const doc = new DOMParser().parseFromString(xml, 'text/xml');
const feed = doc.documentElement;

const kids = (el, name) => Array.from(el.getElementsByTagNameNS(ATOM, name))
  .filter((n) => n.parentNode === el);

for (const required of ['id', 'title', 'updated']) {
  if (kids(feed, required).length !== 1) {
    console.error('feed must have exactly one <' + required + '>');
  }
}

const feedHasAuthor = kids(feed, 'author').length > 0;
const seen = new Map();

for (const [i, entry] of kids(feed, 'entry').entries()) {
  const n = i + 1;

  const updated = kids(entry, 'updated')[0];
  if (updated && !RFC3339.test(updated.textContent.trim())) {
    console.error('entry ' + n + ' updated is not RFC 3339: ' + updated.textContent.trim());
  }

  const id = kids(entry, 'id')[0];
  const value = id ? id.textContent.trim() : '';
  if (!/^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) {
    console.error('entry ' + n + ' id is not an absolute IRI: ' + value);
  } else if (seen.has(value)) {
    console.error('entry ' + n + ' repeats the id of entry ' + seen.get(value));
  } else {
    seen.set(value, n);
  }

  // The inheritance chain: entry/author, else entry/source/author, else feed/author.
  const source = kids(entry, 'source')[0];
  const hasAuthor = kids(entry, 'author').length > 0
    || (source ? kids(source, 'author').length > 0 : false)
    || feedHasAuthor;
  if (!hasAuthor) console.error('entry ' + n + ' has no resolvable author');

  const hasAlternate = kids(entry, 'link')
    .some((l) => (l.getAttribute('rel') || 'alternate') === 'alternate');
  if (kids(entry, 'content').length === 0 && !hasAlternate) {
    console.error('entry ' + n + ' has neither <content> nor a <link rel="alternate">');
  }
}

// Producing a correct timestamp:
console.log(new Date().toISOString());   // 2026-03-14T09:30:00.000Z

# pip install lxml requests
import re
import sys
import requests
from datetime import datetime, timezone
from lxml import etree

ATOM = 'http://www.w3.org/2005/Atom'
NS = {'a': ATOM}

# datetime.fromisoformat is too permissive for this: it accepts a lowercase
# separator, which RFC 4287 section 3.3 forbids. Check the shape directly.
RFC3339 = re.compile(r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$')
IRI = re.compile(r'^[A-Za-z][A-Za-z0-9+.\-]*:')

raw = requests.get('https://example.com/atom.xml', timeout=30).content
parser = etree.XMLParser(resolve_entities=False, no_network=True, load_dtd=False)
feed = etree.fromstring(raw, parser)

for required in ('id', 'title', 'updated'):
    if len(feed.findall('a:%s' % required, NS)) != 1:
        print('feed must have exactly one <%s>' % required)

feed_has_author = len(feed.findall('a:author', NS)) > 0
seen = {}

for n, entry in enumerate(feed.findall('a:entry', NS), start=1):
    updated = entry.findtext('a:updated', namespaces=NS) or ''
    if not RFC3339.match(updated.strip()):
        print('entry %d updated is not RFC 3339: %s' % (n, updated))

    ident = (entry.findtext('a:id', namespaces=NS) or '').strip()
    if not IRI.match(ident):
        print('entry %d id is not an absolute IRI: %s' % (n, ident))
    elif ident in seen:
        print('entry %d repeats the id of entry %d' % (n, seen[ident]))
    else:
        seen[ident] = n

    has_author = (len(entry.findall('a:author', NS)) > 0
                  or len(entry.findall('a:source/a:author', NS)) > 0
                  or feed_has_author)
    if not has_author:
        print('entry %d has no resolvable author' % n)

    alternates = [l for l in entry.findall('a:link', NS)
                  if l.get('rel', 'alternate') == 'alternate']
    if entry.find('a:content', NS) is None and not alternates:
        print('entry %d has neither <content> nor a <link rel="alternate">' % n)

# Producing a correct timestamp. Both spellings below are valid RFC 3339.
print(datetime.now(timezone.utc).isoformat(timespec='seconds'))          # ...+00:00
print(datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'))         # ...Z

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.ByteArrayInputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.HashMap;
import java.util.Map;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

final String ATOM = "http://www.w3.org/2005/Atom";

byte[] bytes = HttpClient.newHttpClient()
    .send(HttpRequest.newBuilder(URI.create("https://example.com/atom.xml")).build(),
          HttpResponse.BodyHandlers.ofByteArray())
    .body();

DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setNamespaceAware(true);   // without this, every Atom lookup below finds nothing
f.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
f.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
f.setXIncludeAware(false);

Document doc = f.newDocumentBuilder().parse(new ByteArrayInputStream(bytes));
Element feed = doc.getDocumentElement();

boolean feedHasAuthor = childCount(feed, ATOM, "author") > 0;
Map<String, Integer> seen = new HashMap<>();

NodeList entries = feed.getElementsByTagNameNS(ATOM, "entry");
for (int i = 0; i < entries.getLength(); i++) {
    Element entry = (Element) entries.item(i);
    int n = i + 1;

    String updated = firstText(entry, ATOM, "updated");
    // java.time matches literals case-sensitively, but check explicitly so the
    // lowercase case gets its own message: RFC 4287 requires "T" and "Z".
    if (updated.indexOf('t') >= 0 || updated.indexOf('z') >= 0) {
        System.err.println("entry " + n + " updated uses a lowercase T or Z: " + updated);
    } else {
        try {
            OffsetDateTime.parse(updated);
        } catch (DateTimeParseException e) {
            System.err.println("entry " + n + " updated is not RFC 3339: " + updated);
        }
    }

    String id = firstText(entry, ATOM, "id");
    if (!id.matches("[A-Za-z][A-Za-z0-9+.\\-]*:.+")) {
        System.err.println("entry " + n + " id is not an absolute IRI: " + id);
    } else if (seen.containsKey(id)) {
        System.err.println("entry " + n + " repeats the id of entry " + seen.get(id));
    } else {
        seen.put(id, n);
    }

    // entry/author, else entry/source/author, else feed/author.
    NodeList sources = entry.getElementsByTagNameNS(ATOM, "source");
    boolean sourceAuthor = sources.getLength() > 0
        && childCount((Element) sources.item(0), ATOM, "author") > 0;
    if (childCount(entry, ATOM, "author") == 0 && !sourceAuthor && !feedHasAuthor) {
        System.err.println("entry " + n + " has no resolvable author");
    }
}

// Producing a correct timestamp:
System.out.println(DateTimeFormatter.ISO_INSTANT.format(Instant.now()));

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

XNamespace atom = "http://www.w3.org/2005/Atom";

// RFC 4287 section 3.3: uppercase T, and uppercase Z when there is no offset.
// The literals are quoted so they are matched exactly rather than as specifiers.
string[] rfc3339 =
{
    "yyyy-MM-dd'T'HH:mm:ssK",
    "yyyy-MM-dd'T'HH:mm:ss.FFFFFFFK",
};

var settings = new XmlReaderSettings
{
    DtdProcessing = DtdProcessing.Prohibit,  // external entities are never fetched
    XmlResolver = null,
};

var bytes = await new HttpClient().GetByteArrayAsync("https://example.com/atom.xml");
using var stream = new MemoryStream(bytes);
using var reader = XmlReader.Create(stream, settings);
var feed = XDocument.Load(reader).Root!;

foreach (var required in new[] { "id", "title", "updated" })
{
    if (feed.Elements(atom + required).Count() != 1)
        Console.Error.WriteLine("feed must have exactly one <" + required + ">");
}

bool feedHasAuthor = feed.Elements(atom + "author").Any();
var seen = new Dictionary<string, int>(StringComparer.Ordinal);
int n = 0;

foreach (var entry in feed.Elements(atom + "entry"))
{
    n++;

    var updated = ((string?)entry.Element(atom + "updated") ?? string.Empty).Trim();
    if (!DateTimeOffset.TryParseExact(updated, rfc3339, CultureInfo.InvariantCulture,
                                      DateTimeStyles.None, out _))
    {
        Console.Error.WriteLine("entry " + n + " updated is not RFC 3339: " + updated);
    }

    var id = ((string?)entry.Element(atom + "id") ?? string.Empty).Trim();
    if (!Uri.IsWellFormedUriString(id, UriKind.Absolute))
        Console.Error.WriteLine("entry " + n + " id is not an absolute IRI: " + id);
    else if (seen.TryGetValue(id, out int first))
        Console.Error.WriteLine("entry " + n + " repeats the id of entry " + first);
    else
        seen[id] = n;

    // entry/author, else entry/source/author, else feed/author.
    bool hasAuthor = entry.Elements(atom + "author").Any()
        || entry.Elements(atom + "source").Elements(atom + "author").Any()
        || feedHasAuthor;
    if (!hasAuthor) Console.Error.WriteLine("entry " + n + " has no resolvable author");

    bool hasAlternate = entry.Elements(atom + "link")
        .Any(l => ((string?)l.Attribute("rel") ?? "alternate") == "alternate");
    if (entry.Element(atom + "content") is null && !hasAlternate)
        Console.Error.WriteLine("entry " + n + " has no content and no alternate link");
}

// Producing a correct timestamp: "o" on a UTC DateTime ends in Z.
Console.WriteLine(DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture));

# RFC 4287 Appendix B carries a RELAX NG Compact schema for Atom. trang
# converts it to the XML syntax xmllint understands.
trang atom.rnc atom.rng
xmllint --noout --nonet --relaxng atom.rng feed.xml

# That schema is informative and cannot express every rule in the RFC. Author
# inheritance and id uniqueness are two of the rules it cannot state, so check
# them separately. Entries carrying no author of their own:
xmlstarlet sel -N a=http://www.w3.org/2005/Atom \
  -t -v 'count(//a:entry[not(a:author) and not(a:source/a:author)])' -n feed.xml
# If that is not zero, the <feed> element itself needs an <author>.

# Duplicate entry ids. Any output at all is a bug:
xmlstarlet sel -N a=http://www.w3.org/2005/Atom \
  -t -m '//a:entry/a:id' -v . -n feed.xml | sort | uniq -d

# Timestamps with a lowercase t or z, which RFC 4287 section 3.3 forbids:
grep -n -E '<(updated|published)>[^<]*[tz]' feed.xml