From 06da70ec389f7e241493ffad22a06f76f7507ea3 Mon Sep 17 00:00:00 2001 From: Matthias Andreas Benkard Date: Sun, 16 Aug 2026 07:34:12 +0200 Subject: =?UTF-8?q?Die=20Startseite=20f=C3=BChrt=20die=20Neuank=C3=B6mmlin?= =?UTF-8?q?ge=20ein?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Seit der Inbetriebnahme setzte die Startseite voraus, was gerade nicht hat, wer sie zum ersten Mal aufruft: geeignete Dateien. Über dem Formular stand die Tätigkeitsbeschreibung, darunter zwei leere Dateifelder, und wer nie mit gii-Norm-XML oder einem BGBl-Regelungstext zu tun hatte, konnte das Werkzeug nicht einmal ausprobieren. Ein zugeklappter Block tritt hinzu, der zwei durchgerechnete Fälle mit Verweisen auf die amtlichen Fundstellen anbietet. Zugeklappt kostet er eine Zeile; das Formular bleibt, wo es war. Angeboten werden ein verkündetes Änderungsgesetz — das UWG nebst dem Dritten Gesetz zu seiner Änderung (BGBl. 2026 I Nr. 43), neunzehn Befehle an sechs Normen ohne Rest — und ein Gesetzentwurf — das AGG nebst BT-Drs. 21/6178, dreiundzwanzig Befehle an vierzehn Normen, einer zur Prüfung markiert. Der zweite Fall war zunächst als ProdHaftG nebst BT-Drs. 21/4297 gedacht und ist verworfen: Die Modernisierung löst das Gesetz ab, statt es zu ändern, und ergibt einen einzigen Befehl an einer einzigen Norm. Ein Beispiel, das nichts zeigt, ist keines. Mitausgeliefert wird nichts, und die Seite ruft von sich aus nichts ab; sie verweist. Die Verweise öffnen ein eigenes Fenster, weil ein im selben Fenster geöffnetes PDF die bereits gewählten Dateien aus dem Formular nähme. Das Stilblatt bekommt .einfuehrung im Zuschnitt der übrigen Kästen und keine einzige neue Farbe, sodass Hell- und Dunkelfassung ohne Zutun stimmen. Dabei stellte sich heraus, dass gesetze-im-internet.de das Norm-XML gar nicht als solches ausgibt: Es gibt allein …//xml.zip, der unmittelbare BJNR….xml-Pfad ist 404. Eine Einführung, die auf die Fundstelle verweist, wäre ohne Weiteres eine Anleitung zum Entpacken von Hand gewesen. Der Ladepfad nimmt das Archiv deshalb nun unmittelbar an (ZipAuspacker, vorgeschaltet in Pipeline.ladeStammgesetz; DateiTyp kennt die Art ZIP). Die Änderungsdokumente bleiben unberührt — Gesetzblätter und Drucksachen kommen nirgends als Archiv. Das Format wird von Hand gelesen, und zwar aus einem Grund, der außerhalb der Browserfassung sinnlos wäre: Von den Archivklassen des JDK trägt dort allein der Inflater, den InflaterErsatz auf jzlib zurückführt; ZipInputStream, ZipFile und CRC32 beruhen auf nativen Bindungen, die Web Image nicht kennt. Auch die Prüfsumme rechnet die Klasse deshalb selbst. Gelesen wird über das Zentralverzeichnis am Dateiende, nicht über die örtlichen Vorspanne, deren Größenangaben bei nachgestellten Beschreibern erst hinter den Daten stehen. Gewählt wird der einzige auf .xml endende Eintrag: Den Gesetzen mit Anlagen legt die Fundstelle deren Bilddateien mit ins Archiv, es ist also nicht einerlei, welchen man nimmt. Die ZIP-Signatur wird vor der PDF-Signatur geprüft, weil sie am ersten Byte verankert ist, während jene ein Vorschaufenster durchsucht — ein Archiv mit der Zeichenfolge „%PDF-“ in seinen gepackten Daten wäre sonst als PDF angesprochen worden. Die Quellenzeile der Synopse nennt weiterhin die angegebene Datei (uwg.zip), nicht den Eintrag; sie soll den Weg zur Fundstelle zurück beschreiben. Den Eintragsnamen trägt die ausgepackte Quelle gleichwohl, damit Protokoll und Ladefehler das Gesetz benennen und nicht seine Verpackung. Geprüft ist beides gegen die Fundstelle selbst, nicht nur gegen den Beispielkorpus: 312 Prüfungen laufen durch, darunter acht neue zum Auspacken. Das unmittelbar bezogene uwg.zip ergibt auf der Befehlszeile mit dem BGBl-Regelungstext dieselbe Ausfertigung wie die entpackte Fassung — die beiden unterscheiden sich allein in der Quellenzeile —, und dieselben 19/0/6 ergeben sich im neu gebauten Wasm-Modul im Browser, ohne eine Beanstandung in der Konsole. Der Block hält bei 320 Pixeln Breite ohne Überlauf. Unberührt bleiben pom.xml, deploy/webpaket.sh und die nginx-Vorlage: Da nichts mitausgeliefert wird, braucht es weder einen zweiten Ressourcen-Block noch neue MIME-Typen — deren types-Block ersetzt die Zuordnung vollständig und wäre sonst die Falle gewesen. Co-Authored-By: Claude Opus 5 Change-Id: I5f6566ca89aa5198452b0b29ac5b38da9eb26137 --- src/main/java/eu/mulk/aendggner/DateiTyp.java | 21 +- src/main/java/eu/mulk/aendggner/Pipeline.java | 15 +- src/main/java/eu/mulk/aendggner/ZipAuspacker.java | 268 +++++++++++++++++++++ .../aenderung/parse/PatchTextExtraktor.java | 2 +- .../aendggner/gesetz/land/LandesRechtLoader.java | 2 +- .../resources/eu/mulk/aendggner/web/index.html | 57 ++++- src/main/resources/eu/mulk/aendggner/web/style.css | 39 +++ .../java/eu/mulk/aendggner/ZipAuspackerTest.java | 138 +++++++++++ 8 files changed, 529 insertions(+), 13 deletions(-) create mode 100644 src/main/java/eu/mulk/aendggner/ZipAuspacker.java create mode 100644 src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java (limited to 'src') diff --git a/src/main/java/eu/mulk/aendggner/DateiTyp.java b/src/main/java/eu/mulk/aendggner/DateiTyp.java index 2157fc4..6e31dc1 100644 --- a/src/main/java/eu/mulk/aendggner/DateiTyp.java +++ b/src/main/java/eu/mulk/aendggner/DateiTyp.java @@ -3,22 +3,33 @@ package eu.mulk.aendggner; import java.nio.charset.StandardCharsets; /** - * Die drei Eingabeformate, die ÄndGgner unterscheidet, erkannt an den ersten Bytes. + * Die Eingabeformate, die ÄndGgner unterscheidet, erkannt an den ersten Bytes. * - *

Ersetzt die frühere Tika-Erkennung: Unterschieden werden muss nur zwischen PDF, gii-XML und - * Klartext, und dafür genügen die Signaturbytes. Das spart eine schwergewichtige Abhängigkeit samt - * ServiceLoader- und XML-Konfiguration — was der Wasm-Übersetzung zugutekommt, für die jede + *

Ersetzt die frühere Tika-Erkennung: Unterschieden werden muss nur zwischen ZIP, PDF, gii-XML + * und Klartext, und dafür genügen die Signaturbytes. Das spart eine schwergewichtige Abhängigkeit + * samt ServiceLoader- und XML-Konfiguration — was der Wasm-Übersetzung zugutekommt, für die jede * dynamisch aufgelöste Abhängigkeit Handarbeit bedeutet. */ public enum DateiTyp { PDF, XML, + ZIP, KLARTEXT; /** Wie weit hinein nach der Signatur gesucht wird (PDFs tragen gelegentlich Vorspann). */ private static final int VORSCHAU_BYTES = 1024; public static DateiTyp erkenne(byte[] inhalt) { + // Die ZIP-Signatur steht an Byte 0 und wird deshalb zuerst und ohne Vorschaufenster geprüft: + // Ein Archiv, das zufällig „%PDF-“ in seinen komprimierten Daten führt, wäre sonst ein PDF. + if (inhalt.length >= 4 + && inhalt[0] == 'P' + && inhalt[1] == 'K' + && inhalt[2] == 3 + && inhalt[3] == 4) { + return ZIP; + } + // ISO-8859-1 bildet jedes Byte auf genau ein Zeichen ab — hier geht es um Signaturen, nicht // um lesbaren Text, und die Zeichenzählung soll der Byteposition entsprechen. var vorschau = @@ -41,7 +52,7 @@ public enum DateiTyp { return KLARTEXT; } - /** Für Fehlermeldungen: „PDF“, „XML“, „Klartext“. */ + /** Für Fehlermeldungen: „PDF“, „XML“, „ZIP“, „Klartext“. */ public String anzeigeName() { return this == KLARTEXT ? "Klartext" : name(); } diff --git a/src/main/java/eu/mulk/aendggner/Pipeline.java b/src/main/java/eu/mulk/aendggner/Pipeline.java index 4b2b7d9..16df275 100644 --- a/src/main/java/eu/mulk/aendggner/Pipeline.java +++ b/src/main/java/eu/mulk/aendggner/Pipeline.java @@ -278,11 +278,18 @@ public final class Pipeline { return ladeStammgesetz(Quelle.lies(baseFile)); } - /** Gii-XML → {@link GiiXmlLoader}; PDF/Klartext (Landesrecht) → {@link LandesRechtLoader}. */ + /** + * Gii-XML → {@link GiiXmlLoader}; PDF/Klartext (Landesrecht) → {@link LandesRechtLoader}. + * + *

Vorweg wird ausgepackt: gesetze-im-internet.de gibt das Norm-XML nur als {@code xml.zip} + * aus, und das soll unentpackt taugen (siehe {@link ZipAuspacker}). Die Änderungsdokumente + * bleiben davon unberührt — Gesetzblätter und Drucksachen kommen nirgends als Archiv. + */ static Gesetz ladeStammgesetz(Quelle baseFile) throws Exception { - return DateiTyp.erkenne(baseFile.inhalt()) == DateiTyp.XML - ? new GiiXmlLoader().load(baseFile) - : new LandesRechtLoader().load(baseFile); + var quelle = ZipAuspacker.auspacken(baseFile); + return DateiTyp.erkenne(quelle.inhalt()) == DateiTyp.XML + ? new GiiXmlLoader().load(quelle) + : new LandesRechtLoader().load(quelle); } /** diff --git a/src/main/java/eu/mulk/aendggner/ZipAuspacker.java b/src/main/java/eu/mulk/aendggner/ZipAuspacker.java new file mode 100644 index 0000000..0baeac2 --- /dev/null +++ b/src/main/java/eu/mulk/aendggner/ZipAuspacker.java @@ -0,0 +1,268 @@ +package eu.mulk.aendggner; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.List; +import java.util.zip.DataFormatException; +import java.util.zip.Inflater; + +/** + * Holt das gii-Norm-XML aus einem Archiv heraus, wie gesetze-im-internet.de es ausliefert. + * + *

Das Portal gibt kein rohes XML aus, sondern je Gesetz nur {@code …//xml.zip}. Ohne + * diesen Schritt müsste jede:r die heruntergeladene Datei erst von Hand entpacken, bevor sie ins + * Formular passt — die Einführung der Browserfassung verweist deshalb unmittelbar auf das Archiv. + * + *

Das ZIP-Format wird hier von Hand gelesen statt mit {@link java.util.zip.ZipInputStream}: Von + * allen zip-Klassen des JDK trägt in der Wasm-Fassung allein {@link Inflater}, den {@code + * eu.mulk.aendggner.wasm.InflaterErsatz} durch die reine Java-Umsetzung von jzlib ersetzt. {@code + * ZipInputStream}, {@code ZipFile} und {@code CRC32} greifen auf native Bindungen zurück, die Web + * Image nicht kennt; die Prüfsumme rechnet deshalb {@link #crc32} selbst. + * + *

Gelesen wird über das Zentralverzeichnis am Dateiende, nicht über die Local Header: Bei + * Einträgen mit Data Descriptor stehen Größe und Prüfsumme im Local Header auf null und erst hinter + * den komprimierten Daten — das Zentralverzeichnis trägt sie immer. + */ +public final class ZipAuspacker { + + /** „PK\05\06“ — Kennung des End-of-Central-Directory-Records. */ + private static final int EOCD_SIGNATUR = 0x06054b50; + + /** „PK\01\02“ — Kennung eines Eintrags im Zentralverzeichnis. */ + private static final int ZENTRAL_SIGNATUR = 0x02014b50; + + /** „PK\03\04“ — Kennung eines Local Headers. */ + private static final int LOKAL_SIGNATUR = 0x04034b50; + + /** Fester Teil des EOCD-Records; dahinter steht nur noch der Archivkommentar. */ + private static final int EOCD_MINDESTLAENGE = 22; + + /** Der Kommentar ist auf 64 KiB begrenzt; weiter zurück muss die Suche nach dem EOCD nicht. */ + private static final int KOMMENTAR_MAX = 0xFFFF; + + private static final int VERFAHREN_GESPEICHERT = 0; + private static final int VERFAHREN_DEFLATE = 8; + + /** Bit 0 des Allgemeinen Kennzeichens: Der Eintrag ist verschlüsselt. */ + private static final int KENNZEICHEN_VERSCHLUESSELT = 1; + + private ZipAuspacker() {} + + /** + * Liefert bei einem Archiv den enthaltenen XML-Eintrag, sonst die Quelle unverändert. + * + *

Die gelieferte Quelle trägt den Eintragsnamen, damit Protokoll und Ladefehler das Gesetz + * benennen statt seine Verpackung. Die Quellenzeile der Synopse bleibt davon unberührt: Sie nennt + * weiterhin die Datei, die angegeben wurde ({@code uwg.zip}), denn sie soll den Weg zur + * Fundstelle zurück beschreiben. + */ + public static Quelle auspacken(Quelle quelle) throws IOException { + if (DateiTyp.erkenne(quelle.inhalt()) != DateiTyp.ZIP) { + return quelle; + } + + var eintraege = zentralverzeichnis(quelle); + var xml = einzigesXml(eintraege, quelle.name()); + return new Quelle(xml.name(), entpacke(quelle.inhalt(), xml, quelle.name())); + } + + /** Ein Eintrag des Zentralverzeichnisses, soweit hier gebraucht. */ + private record Eintrag( + String name, + int verfahren, + int kennzeichen, + long crc, + int gepackt, + int entpackt, + int offset) { + + String dateiname() { + int schraeg = name.lastIndexOf('/'); + return schraeg < 0 ? name : name.substring(schraeg + 1); + } + } + + private static List zentralverzeichnis(Quelle quelle) throws IOException { + var bytes = quelle.inhalt(); + int eocd = sucheEocd(bytes, quelle.name()); + + int anzahl = u16(bytes, eocd + 10); + int anfang = (int) u32(bytes, eocd + 16); + + var eintraege = new ArrayList(anzahl); + int p = anfang; + for (int i = 0; i < anzahl; i++) { + if (p < 0 || p + 46 > bytes.length || (int) u32(bytes, p) != ZENTRAL_SIGNATUR) { + throw beschaedigt(quelle.name(), "das Zentralverzeichnis bricht ab"); + } + int namensLaenge = u16(bytes, p + 28); + int zusatzLaenge = u16(bytes, p + 30); + int kommentarLaenge = u16(bytes, p + 32); + if (p + 46 + namensLaenge > bytes.length) { + throw beschaedigt(quelle.name(), "ein Eintragsname reicht über das Dateiende hinaus"); + } + eintraege.add( + new Eintrag( + // Ohne gesetztes Bit 11 des Allgemeinen Kennzeichens schreibt das Format CP437; + // die hier vorkommenden Namen sind reines ASCII, für das beides zusammenfällt. + new String(bytes, p + 46, namensLaenge, StandardCharsets.UTF_8), + u16(bytes, p + 10), + u16(bytes, p + 8), + u32(bytes, p + 16), + (int) u32(bytes, p + 20), + (int) u32(bytes, p + 24), + (int) u32(bytes, p + 42))); + p += 46 + namensLaenge + zusatzLaenge + kommentarLaenge; + } + return eintraege; + } + + /** Sucht den EOCD-Record von hinten: Vor ihm steht nur noch der Archivkommentar. */ + private static int sucheEocd(byte[] bytes, String name) throws IOException { + int frueheste = Math.max(0, bytes.length - EOCD_MINDESTLAENGE - KOMMENTAR_MAX); + for (int p = bytes.length - EOCD_MINDESTLAENGE; p >= frueheste; p--) { + if ((int) u32(bytes, p) == EOCD_SIGNATUR) { + return p; + } + } + throw beschaedigt(name, "das Ende des Zentralverzeichnisses fehlt"); + } + + private static Eintrag einzigesXml(List eintraege, String archiv) throws IOException { + var xml = new ArrayList(); + for (var eintrag : eintraege) { + // Verzeichniseinträge tragen keinen Inhalt; „__MACOSX/“ ist Beiwerk, das macOS beim Packen + // hinzufügt und dessen Namen die der echten Einträge spiegeln. + if (eintrag.name().endsWith("/") || eintrag.name().startsWith("__MACOSX/")) { + continue; + } + // gii legt Gesetzen mit Anlagen deren Bilddateien mit ins Archiv — es ist deshalb nicht + // einerlei, welcher Eintrag genommen wird. + if (eintrag.dateiname().toLowerCase().endsWith(".xml")) { + xml.add(eintrag); + } + } + + if (xml.isEmpty()) { + throw new IOException( + "Das Archiv %s enthält keine XML-Datei; erwartet wird das gii-Norm-XML von" + .formatted(archiv) + + " gesetze-im-internet.de (xml.zip)"); + } + if (xml.size() > 1) { + throw new IOException( + "Das Archiv %s enthält mehrere XML-Dateien (%s); bitte die gewünschte entpackt angeben" + .formatted(archiv, String.join(", ", xml.stream().map(Eintrag::name).toList()))); + } + return xml.getFirst(); + } + + private static byte[] entpacke(byte[] bytes, Eintrag eintrag, String archiv) throws IOException { + if ((eintrag.kennzeichen() & KENNZEICHEN_VERSCHLUESSELT) != 0) { + throw new IOException( + "Der Eintrag %s im Archiv %s ist verschlüsselt".formatted(eintrag.name(), archiv)); + } + + // Der Local Header wiederholt Name und Zusatzfeld, und zwar mit eigenen Längen — die Daten + // beginnen erst dahinter. + int lokal = eintrag.offset(); + if (lokal < 0 || lokal + 30 > bytes.length || (int) u32(bytes, lokal) != LOKAL_SIGNATUR) { + throw beschaedigt( + archiv, + "der Eintrag %s steht nicht dort, wo das Zentralverzeichnis ihn führt" + .formatted(eintrag.name())); + } + int daten = lokal + 30 + u16(bytes, lokal + 26) + u16(bytes, lokal + 28); + if (daten < 0 || eintrag.gepackt() < 0 || daten + eintrag.gepackt() > bytes.length) { + throw beschaedigt( + archiv, "der Eintrag %s reicht über das Dateiende hinaus".formatted(eintrag.name())); + } + + var inhalt = + switch (eintrag.verfahren()) { + case VERFAHREN_GESPEICHERT -> { + var kopie = new byte[eintrag.gepackt()]; + System.arraycopy(bytes, daten, kopie, 0, eintrag.gepackt()); + yield kopie; + } + case VERFAHREN_DEFLATE -> + inflate(bytes, daten, eintrag.gepackt(), eintrag.entpackt(), eintrag.name(), archiv); + default -> + throw new IOException( + "Der Eintrag %s im Archiv %s ist mit dem unbekannten Verfahren %d gepackt" + .formatted(eintrag.name(), archiv, eintrag.verfahren())); + }; + + if (crc32(inhalt) != eintrag.crc()) { + throw beschaedigt( + archiv, "die Prüfsumme des Eintrags %s stimmt nicht".formatted(eintrag.name())); + } + return inhalt; + } + + /** + * Rohes Deflate ohne zlib-Rahmen — daher {@code new Inflater(true)}. Die Ausgabegröße steht im + * Zentralverzeichnis, es wird also genau einmal ausgelesen und nicht nachgewachsen. + */ + private static byte[] inflate( + byte[] bytes, int von, int gepackt, int entpackt, String eintrag, String archiv) + throws IOException { + if (entpackt < 0) { + throw beschaedigt( + archiv, "der Eintrag %s gibt eine unbrauchbare Größe an".formatted(eintrag)); + } + var inflater = new Inflater(true); + try { + inflater.setInput(bytes, von, gepackt); + var aus = new byte[entpackt]; + int gefuellt = 0; + while (gefuellt < entpackt) { + int geschrieben = inflater.inflate(aus, gefuellt, entpackt - gefuellt); + if (geschrieben == 0 && (inflater.finished() || inflater.needsInput())) { + throw beschaedigt( + archiv, "der Eintrag %s endet vor der angegebenen Größe".formatted(eintrag)); + } + gefuellt += geschrieben; + } + return aus; + } catch (DataFormatException e) { + throw new IOException( + "Der Eintrag %s im Archiv %s lässt sich nicht entpacken: %s" + .formatted(eintrag, archiv, e.getMessage()), + e); + } finally { + inflater.end(); + } + } + + /** + * CRC-32 (IEEE 802.3) in reinem Java. {@code java.util.zip.CRC32} ruft eine native Routine des + * JDK auf, die Web Image nicht kennt; die Tabelle wird deshalb hier aufgebaut. + */ + private static long crc32(byte[] daten) { + long crc = 0xFFFFFFFFL; + for (var b : daten) { + crc ^= b & 0xFF; + for (int i = 0; i < 8; i++) { + crc = (crc >>> 1) ^ (0xEDB88320L & -(crc & 1)); + } + } + return crc ^ 0xFFFFFFFFL; + } + + private static IOException beschaedigt(String archiv, String grund) { + return new IOException("Das Archiv %s ist beschädigt: %s".formatted(archiv, grund)); + } + + private static int u16(byte[] bytes, int p) { + return (bytes[p] & 0xFF) | ((bytes[p + 1] & 0xFF) << 8); + } + + private static long u32(byte[] bytes, int p) { + return (bytes[p] & 0xFFL) + | ((bytes[p + 1] & 0xFFL) << 8) + | ((bytes[p + 2] & 0xFFL) << 16) + | ((bytes[p + 3] & 0xFFL) << 24); + } +} diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java index daa72c5..876f0b5 100644 --- a/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java +++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java @@ -44,7 +44,7 @@ public final class PatchTextExtraktor { return switch (typ) { case PDF -> extrahierePdf(quelle.inhalt()); case KLARTEXT -> new String(quelle.inhalt(), StandardCharsets.UTF_8); - case XML -> + case XML, ZIP -> throw new IOException( "Nicht unterstützter Dateityp %s für %s (unterstützt: PDF, Klartext)" .formatted(typ.anzeigeName(), quelle.name())); diff --git a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java index 22c1e41..f5e777a 100644 --- a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java +++ b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java @@ -49,7 +49,7 @@ public final class LandesRechtLoader { case KLARTEXT -> Normalizer.normalize( new String(quelle.inhalt(), StandardCharsets.UTF_8), Normalizer.Form.NFC); - case XML -> + case XML, ZIP -> throw new IOException( "Nicht unterstützter Dateityp %s für Stammgesetz %s (unterstützt: PDF, Klartext)" .formatted(typ.anzeigeName(), quelle.name())); diff --git a/src/main/resources/eu/mulk/aendggner/web/index.html b/src/main/resources/eu/mulk/aendggner/web/index.html index 4bdaa05..56fd88b 100644 --- a/src/main/resources/eu/mulk/aendggner/web/index.html +++ b/src/main/resources/eu/mulk/aendggner/web/index.html @@ -34,13 +34,66 @@

+
+ Noch keine Dateien? Zwei Beispiele zum Ausprobieren + +

+ Das Werkzeug braucht zweierlei: das Stammgesetz in seiner geltenden + Fassung und das Änderungsdokument, das es ändert. Beides liegt bei den + amtlichen Stellen bereit. +

+ +
    +
  1. Die beiden Dateien eines Beispiels herunterladen.
    2. +
  2. Sie in die Felder darunter eintragen — das xml.zip so, wie es kommt, ohne Entpacken.
    3. +
  3. „Synopse erzeugen“ drücken.
    4. +
+ +
+
Verkündetes Änderungsgesetz — Gesetz gegen den unlauteren Wettbewerb
+
+ Stammgesetz: + UWG (xml.zip, 22 KB)
+ Änderung: + Drittes Gesetz zur Änderung des UWG, + BGBl. 2026 I Nr. 43 (PDF, 0,3 MB)
+ 19 Befehle an 6 Normen, nichts manuell zu prüfen. +
+ +
Gesetzentwurf — Allgemeines Gleichbehandlungsgesetz
+
+ Stammgesetz: + AGG (xml.zip, 14 KB)
+ Änderung: + Zweites Gesetz zur Änderung des AGG, + BT-Drs. 21/6178 (PDF, 0,5 MB)
+ + 23 Befehle an 14 Normen, einer zur manuellen Prüfung markiert. Zeigt zugleich, was + gälte, wenn der Entwurf so beschlossen würde — der Begründungsteil dahinter erzeugt + keine Befehle. + +
+
+ +

+ Die Verweise führen zu gesetze-im-internet.de, recht.bund.de und dserver.bundestag.de. Das + Werkzeug ruft dort nichts von sich aus ab: Es sieht nur die Dateien, die Sie ihm im Formular + übergeben. +

+
+

- gii-Norm-XML von gesetze-im-internet.de, oder — für Landesrecht — die konsolidierte - Fassung aus dem Landesportal (PDF oder Klartext). + gii-Norm-XML von gesetze-im-internet.de — auch als heruntergeladenes xml.zip, ohne + Entpacken —, oder für Landesrecht die konsolidierte Fassung aus dem Landesportal (PDF + oder Klartext).

diff --git a/src/main/resources/eu/mulk/aendggner/web/style.css b/src/main/resources/eu/mulk/aendggner/web/style.css index ac3b8ee..c9d6db1 100644 --- a/src/main/resources/eu/mulk/aendggner/web/style.css +++ b/src/main/resources/eu/mulk/aendggner/web/style.css @@ -121,6 +121,45 @@ button:hover { font-size: 0.875rem; } +/* Zugeklappt eine Zeile, damit das Formular oben bleibt; aufgeklappt im Zuschnitt der + übrigen Kästen. */ +.einfuehrung { + margin: 0 0 1.75rem; + padding: 0.75rem 1rem; + border: 1px solid var(--border); + border-radius: 6px; + font-size: 0.875rem; +} + +.einfuehrung summary { + font-weight: bold; + color: var(--accent); + cursor: pointer; +} + +.einfuehrung > :not(summary) { + margin: 0.75rem 0 0; +} + +.einfuehrung ol { + padding-left: 1.25rem; +} + +.einfuehrung dt { + font-weight: bold; + margin-top: 0.75rem; +} + +.einfuehrung dd { + margin: 0.25rem 0 0; +} + +/* Der Erläuterungssatz unter einem Beispiel steht als span in der dd und braucht deshalb + eigene Absatzbildung. */ +.einfuehrung .hint { + display: block; +} + .disclaimer { margin-top: 2rem; padding: 1rem; diff --git a/src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java b/src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java new file mode 100644 index 0000000..5f0530d --- /dev/null +++ b/src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java @@ -0,0 +1,138 @@ +package eu.mulk.aendggner; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.zip.CRC32; +import java.util.zip.ZipEntry; +import java.util.zip.ZipOutputStream; +import org.junit.jupiter.api.Test; + +/** + * Die Archive werden zur Laufzeit gebaut statt als Binärdatei abgelegt: So steht neben jedem Fall, + * was ihn ausmacht, und der Quellbaum bleibt frei von undurchsichtigen Beilagen. + */ +class ZipAuspackerTest { + + private static final Path MINI_GII = Path.of("src/test/resources/eu/mulk/aendggner/mini-gii.xml"); + + @Test + void packtDenXmlEintragAus() throws Exception { + var xml = Files.readAllBytes(MINI_GII); + var archiv = zip(Map.of("BJNR000000000.xml", xml), ZipEntry.DEFLATED); + + var ausgepackt = ZipAuspacker.auspacken(new Quelle("xml.zip", archiv)); + + assertThat(ausgepackt.inhalt()).isEqualTo(xml); + // Der Name folgt dem Eintrag, nicht der Verpackung: Protokoll und Ladefehler sollen das + // Gesetz benennen. + assertThat(ausgepackt.name()).isEqualTo("BJNR000000000.xml"); + } + + @Test + void packtAuchUnkomprimierteEintraegeAus() throws Exception { + var xml = Files.readAllBytes(MINI_GII); + var archiv = zip(Map.of("BJNR000000000.xml", xml), ZipEntry.STORED); + + assertThat(ZipAuspacker.auspacken(new Quelle("xml.zip", archiv)).inhalt()).isEqualTo(xml); + } + + @Test + void uebergehtBeiwerkNebenDemXml() throws Exception { + var xml = Files.readAllBytes(MINI_GII); + // So sehen die Archive der Gesetze mit Anlagen aus: neben dem Norm-XML liegen Bilddateien. + var eintraege = new LinkedHashMap(); + eintraege.put("__MACOSX/", new byte[0]); + eintraege.put("BJNR000000000.xml", xml); + eintraege.put("anlage_1.gif", new byte[] {'G', 'I', 'F', '8'}); + + assertThat(ZipAuspacker.auspacken(new Quelle("xml.zip", zip(eintraege, ZipEntry.DEFLATED)))) + .extracting(Quelle::name) + .isEqualTo("BJNR000000000.xml"); + } + + @Test + void reichtNichtArchiveUnveraendertDurch() throws Exception { + var quelle = new Quelle("stamm.xml", Files.readAllBytes(MINI_GII)); + + assertThat(ZipAuspacker.auspacken(quelle)).isSameAs(quelle); + } + + @Test + void meldetArchivOhneXml() { + var archiv = zip(Map.of("liesmich.txt", "nichts hierin".getBytes(StandardCharsets.UTF_8))); + + assertThatThrownBy(() -> ZipAuspacker.auspacken(new Quelle("xml.zip", archiv))) + .isInstanceOf(IOException.class) + .hasMessageContaining("keine XML-Datei"); + } + + @Test + void meldetArchivMitMehrerenXml() { + var eintraege = new LinkedHashMap(); + eintraege.put("eins.xml", "".getBytes(StandardCharsets.UTF_8)); + eintraege.put("zwei.xml", "".getBytes(StandardCharsets.UTF_8)); + + assertThatThrownBy(() -> ZipAuspacker.auspacken(new Quelle("xml.zip", zip(eintraege)))) + .isInstanceOf(IOException.class) + .hasMessageContaining("eins.xml, zwei.xml"); + } + + @Test + void meldetBeschaedigtesArchiv() throws Exception { + var archiv = zip(Map.of("BJNR000000000.xml", Files.readAllBytes(MINI_GII))); + // Das Zentralverzeichnis steht am Ende; ein abgeschnittenes Archiv verliert es. + var abgeschnitten = new byte[archiv.length / 2]; + System.arraycopy(archiv, 0, abgeschnitten, 0, abgeschnitten.length); + + assertThatThrownBy(() -> ZipAuspacker.auspacken(new Quelle("xml.zip", abgeschnitten))) + .isInstanceOf(IOException.class) + .hasMessageContaining("beschädigt"); + } + + @Test + void gezipptesStammgesetzErgibtDasselbeGesetz() throws Exception { + var xml = Files.readAllBytes(MINI_GII); + + var direkt = Pipeline.ladeStammgesetz(new Quelle("mini-gii.xml", xml)); + var gezippt = Pipeline.ladeStammgesetz(new Quelle("xml.zip", zip(Map.of("mini-gii.xml", xml)))); + + assertThat(gezippt.normen()).isEqualTo(direkt.normen()); + assertThat(gezippt.jurabk()).isEqualTo(direkt.jurabk()); + } + + private static byte[] zip(Map eintraege) { + return zip(eintraege, ZipEntry.DEFLATED); + } + + private static byte[] zip(Map eintraege, int verfahren) { + var aus = new ByteArrayOutputStream(); + try (var zip = new ZipOutputStream(aus)) { + for (var eintrag : eintraege.entrySet()) { + var kopf = new ZipEntry(eintrag.getKey()); + kopf.setMethod(verfahren); + if (verfahren == ZipEntry.STORED) { + // Gespeicherte Einträge verlangen Größe und Prüfsumme vorab. + var pruefsumme = new CRC32(); + pruefsumme.update(eintrag.getValue()); + kopf.setSize(eintrag.getValue().length); + kopf.setCompressedSize(eintrag.getValue().length); + kopf.setCrc(pruefsumme.getValue()); + } + zip.putNextEntry(kopf); + zip.write(eintrag.getValue()); + zip.closeEntry(); + } + } catch (IOException e) { + throw new AssertionError("Das Testarchiv ließ sich nicht bauen", e); + } + return aus.toByteArray(); + } +} -- cgit v1.2.1