diff options
Diffstat (limited to 'src/main')
7 files changed, 132 insertions, 8 deletions
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java b/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java index 12a152e..fe29437 100644 --- a/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java +++ b/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java @@ -144,7 +144,35 @@ public record Stelle(List<Komponente> komponenten) { return komponenten.stream() .filter(Gliederungseinheit.class::isInstance) .map(Gliederungseinheit.class::cast) - .anyMatch(g -> !istAnlagenArt(g.art())); + .anyMatch(g -> !istAnlagenArt(g.art()) && !istAnlagenEinheitsArt(g.art())); + } + + /** + * Die benannte Einheit einer Anlage („Ausbildungsabschnitt 1“), falls vorhanden. + * + * <p>Sie gliedert nicht das Gesetz, sondern die Anlage, und wird — wie deren Nummern — als eigene + * Norm geführt, deren Bezeichnung die Anlage voranstellt („Anlage 1 Ausbildungsabschnitt 1“). + */ + public Optional<Gliederungseinheit> anlagenEinheit() { + return komponenten.stream() + .filter(Gliederungseinheit.class::isInstance) + .map(Gliederungseinheit.class::cast) + .filter(g -> istAnlagenEinheitsArt(g.art())) + .findFirst(); + } + + /** + * Trägt die Art den Bau einer benannten Anlagen-Einheit? Buchstaben <em>vor</em> dem Wortstamm + * sind verlangt: „Ausbildungsabschnitt“ trifft, „Abschnitt“ nicht — der gliedert das Gesetz. + */ + private static boolean istAnlagenEinheitsArt(String art) { + // „Unterabschnitt“ endet zwar auf den Wortstamm, gliedert aber das Gesetz und ist keine + // Einheit einer Anlage; ebenso der schlichte „Abschnitt“. + if (art.equalsIgnoreCase("Abschnitt") || art.equalsIgnoreCase("Unterabschnitt")) { + return false; + } + int stelle = art.length() - "abschnitt".length(); + return stelle > 0 && art.regionMatches(true, stelle, "abschnitt", 0, "abschnitt".length()); } /** Die enbez der adressierten Anhang-/Anlagen-Norm („Anhang“, „Anlage 2“), falls vorhanden. */ diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java index dc12398..1d0685b 100644 --- a/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java +++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java @@ -484,7 +484,7 @@ final class BefehlErkenner { Pattern.compile( "^(?:Der bisherige |Die bisherige |Das bisherige )?(.+?) wird (?:zu )?(?:der |die |das )?" + "(§|Art\\.|Absatz|Abs\\.|Satz|Nummer|Nr\\.|Buchstabe|Buchst\\." - + "|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage) " + + "|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage|\\p{L}+abschnitt) " + "(\\d+[a-z]?)\\.$"); // „Die bisherigen Absätze 2 bis 4 werden zu den Absätzen 3 bis 5.“ bzw. „Die bisherigen Nummern 4 @@ -722,7 +722,7 @@ final class BefehlErkenner { Pattern.compile( "^(?:Der bisherige |Die bisherige |Das bisherige )?(.+?) wird (?:zu )?" + "(§|Art\\.|Absatz|Abs\\.|Satz|Nummer|Nr\\.|Buchstabe|Buchst\\." - + "|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage)" + + "|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage|\\p{L}+abschnitt)" // Der Wächter „(?!wird |werden )“ ist nötig: ohne ihn verschlänge die Untereinheit // in der schlichten Form („Abs. 3 wird Abs. 2 und wird wie folgt geändert:“) das // Verb und wäre als Stelle unparsbar. @@ -2194,7 +2194,15 @@ final class BefehlErkenner { case "Buchstabe", "Buchst." -> new Stelle.BuchstabeNr(nummer); case "Teil", "Abschnitt", "Unterabschnitt", "Buch", "Kapitel", "Anlage" -> new Stelle.Gliederungseinheit(ebene, nummer); - default -> throw new IllegalArgumentException("Unbekannte Ebene: " + ebene); + // Die benannte Einheit einer Anlage („Ausbildungsabschnitt 5“) — sie gliedert die Anlage, + // nicht das Gesetz, und wird wie deren Nummern als eigene Norm geführt. + default -> { + if (!ebene.regionMatches(true, Math.max(0, ebene.length() - 9), "abschnitt", 0, 9) + || ebene.length() <= 9) { + throw new IllegalArgumentException("Unbekannte Ebene: " + ebene); + } + yield new Stelle.Gliederungseinheit(ebene, nummer); + } }; } diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java index f6e7360..e772846 100644 --- a/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java +++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java @@ -230,6 +230,18 @@ public final class StellenParser { i++; } default -> { + // Die benannte Einheit einer Anlage: „Im Ausbildungsabschnitt 1 …“. Sie steht nicht in + // der Liste der Gliederungsarten, weil ihr Name der Anlage gehört und nicht dem Gesetz; + // erkannt wird sie an ihrem Bau (siehe istAnlagenEinheit). + if (istAnlagenEinheit(wort)) { + var wert = naechstesWort(woerter, i); + if (wert != null && NUMMER_WERT.matcher(wert).matches()) { + komponenten.add(new Stelle.Gliederungseinheit(anlagenEinheitsArt(wort), wert)); + i++; + continue; + } + return Optional.empty(); + } // Ordinal vor der Gliederungsart: „zum zweiten Abschnitt“, „des 2. Abschnitts“. var ordinal = ordinalZahl(wort); var art = ordinal != null ? naechstesWort(woerter, i) : null; @@ -573,6 +585,29 @@ public final class StellenParser { }; } + /** + * Die benannte Einheit einer Anlage („Ausbildungsabschnitt 1“ des Ausbildungsrahmenplans). + * + * <p>Erkannt wird sie an ihrem Bau und nicht an einer Wortliste: Jede Anlage darf ihre Einheiten + * nennen, wie sie will, und eine Liste wäre am nächsten Land wieder unvollständig. Verlangt sind + * Buchstaben <em>vor</em> dem Wortstamm — „Ausbildungsabschnitt“ trifft, „Abschnitt“ nicht, denn + * der gliedert das Gesetz und ist anderswo geregelt. + */ + private static final Pattern ANLAGEN_EINHEIT = + Pattern.compile("^(\\p{L}+abschnitt)(?:s|e|es|en)?$", Pattern.CASE_INSENSITIVE); + + private static boolean istAnlagenEinheit(String wort) { + // „Unterabschnitt“ endet auf den Wortstamm, gliedert aber das Gesetz; er ist oben abgehandelt + // und darf hier nicht noch einmal zugreifen. + return !istGliederungsArt(wort) && ANLAGEN_EINHEIT.matcher(wort).matches(); + } + + /** Der Nominativ Singular der benannten Einheit („Ausbildungsabschnitts“ → „…abschnitt“). */ + private static String anlagenEinheitsArt(String wort) { + var treffer = ANLAGEN_EINHEIT.matcher(wort); + return treffer.matches() ? treffer.group(1) : wort; + } + /** Normalisiert Genitiv-/Pluralformen der Gliederungsart auf den Nominativ Singular. */ private static String gliederungsArt(String wort) { return switch (wort) { diff --git a/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java b/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java index eb69423..a73ab77 100644 --- a/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java +++ b/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java @@ -2217,6 +2217,38 @@ public final class BefehlAnwender { return angewandt(befehl, enbezNeu); } + // „Der bisherige Ausbildungsabschnitt 5 wird zu Ausbildungsabschnitt 6.“ — die benannte + // Einheit einer Anlage ist eine eigene Norm; umnummeriert wird deren Bezeichnung. Der Befehl + // nennt nur die Einheit, die Norm heißt aber „Anlage 1 Ausbildungsabschnitt 6“: Die Anlage + // steht im Bestand und wird von dort übernommen, nicht aus dem Befehl erraten. + var altEinheit = befehl.stelle().anlagenEinheit(); + var neuEinheit = befehl.neu().anlagenEinheit(); + if (altEinheit.isPresent() && neuEinheit.isPresent()) { + var ergebnis = StellenAufloeser.aufloese(gesetzAus(normen), befehl.stelle()); + if (ergebnis instanceof StellenAufloeser.Ergebnis.NichtGefunden nicht) { + return manuell(befehl, nicht.grund(), nicht.begruendung()); + } + var idx = ((StellenAufloeser.Ergebnis.Gefunden) ergebnis).fundstelle().normIndex(); + var enbezAlt = normen.get(idx).enbez(); + var alteBezeichnung = altEinheit.get().bezeichnung(); + if (!enbezAlt.endsWith(alteBezeichnung)) { + return manuell( + befehl, + Grund.BESTAND_WIDERSPRICHT, + "„" + enbezAlt + "“ trägt nicht die Bezeichnung „" + alteBezeichnung + "“."); + } + var enbezNeu = + enbezAlt.substring(0, enbezAlt.length() - alteBezeichnung.length()) + + neuEinheit.get().bezeichnung(); + if (!enbezNeu.equals(enbezAlt) + && StellenAufloeser.normIndex(gesetzAus(normen), enbezNeu) >= 0) { + return manuell( + befehl, Grund.BESTAND_WIDERSPRICHT, enbezNeu + " existiert bereits im Gesetz."); + } + normen.set(idx, normen.get(idx).mitEnbez(enbezNeu)); + return angewandt(befehl, enbezNeu); + } + var altAbsatz = befehl.stelle().absatz(); var neuAbsatz = befehl.neu().absatz(); // Nur wenn der Absatz selbst das Umnummerierungsziel ist — bei „Satz 5 wird Satz 4“ stammt diff --git a/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java b/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java index 32d9c8b..f9d4ff2 100644 --- a/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java +++ b/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java @@ -64,6 +64,16 @@ final class StellenAufloeser { stelle = stelle.ohne(nummer.get()); } } + // Ebenso die benannte Einheit einer Anlage („Anlage 1 Ausbildungsabschnitt 1“): Sie gliedert + // nicht das Gesetz, sondern die Anlage, und der Ausbildungsrahmenplan führt sie so. + var einheit = stelle.anlagenEinheit(); + if (einheit.isPresent()) { + var alsNorm = enbez + " " + einheit.get().bezeichnung(); + if (normIndex(gesetz, alsNorm) >= 0) { + enbez = alsNorm; + stelle = stelle.ohne(einheit.get()); + } + } } else { return new Ergebnis.NichtGefunden( "Stelle nennt keinen Paragraphen: " + stelle.anzeigeText(), diff --git a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeber.java b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeber.java index 3a82945..74d6e11 100644 --- a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeber.java +++ b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeber.java @@ -40,7 +40,9 @@ public final class LandesRechtTextAusgeber { * Anlagen-Norm stellt den Bezug schon her. */ private static final Pattern ANLAGEN_NUMMER = - Pattern.compile("^(?:Anlage|Anhang)(?:\\s+\\d+[a-z]?)?\\s+((?:Nummer|Nr\\.)\\s+\\d+[a-z]?)$"); + Pattern.compile( + "^(?:Anlage|Anhang)(?:\\s+\\d+[a-z]?)?" + + "\\s+((?:Nummer|Nr\\.|\\p{L}+abschnitt)\\s+\\d+[a-z]?)$"); private LandesRechtTextAusgeber() {} diff --git a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextParser.java b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextParser.java index 7f7e2f4..b93ef5d 100644 --- a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextParser.java +++ b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextParser.java @@ -149,6 +149,16 @@ final class LandesRechtTextParser { "^((?:\\(X+\\) )?(?:§§|Artt\\.) \\S.*?) {2}(\\((?:weggefallen|aufgehoben)\\))$"); /** + * Eine benannte Einheit innerhalb einer Anlage: die Nummer eines Zuständigkeitskatalogs („Nummer + * 6“) ebenso wie der Abschnitt eines Ausbildungsrahmenplans („Ausbildungsabschnitt 1“). + * + * <p>Die zweite Form ist nicht als „Abschnitt“ zu lesen: Ein Abschnitt gliedert das Gesetz, + * innerhalb einer Anlage gliedert nichts mehr. Verlangt sind deshalb Buchstaben <em>vor</em> dem + * Wortstamm — „Ausbildungsabschnitt“ trifft, „Abschnitt“ nicht. + */ + private static final String ANLAGEN_EINHEIT = "(?:Nummer|Nr\\.|\\p{L}+abschnitt)\\s+\\d+[a-z]?"; + + /** * Der Kopf einer Nummer innerhalb einer Anlage („Nummer 6“). Die Nummern eines * Zuständigkeitskatalogs sind keine Aufzählungsglieder, sondern eigene Einheiten mit eigener * Absatzzählung — das Landesrechtsportal führt jede als eigene Einzelnorm, und die @@ -157,7 +167,7 @@ final class LandesRechtTextParser { * voranstellt: „Anlage Nummer 6“. */ private static final Pattern ANLAGEN_NUMMER_KOPF = - Pattern.compile("^(?:Nummer|Nr\\.)\\s+(\\d+[a-z]?)\\s*$"); + Pattern.compile("^(" + ANLAGEN_EINHEIT + ")\\s*$"); private static final Pattern WEGGEFALLEN_TITEL = Pattern.compile("^\\((?:aufgehoben|weggefallen)\\)$"); @@ -331,8 +341,7 @@ final class LandesRechtTextParser { } else if (neueAnlagenNummer) { // „Anlage Nummer 6“ — die Anlage selbst bleibt als Norm vor ihnen stehen; trägt sie // keinen eigenen Wortlaut, so ist sie eben leer. - normEnbez = - (anlagenEnbez != null ? anlagenEnbez + " " : "") + "Nummer " + anlagenNummer.group(1); + normEnbez = (anlagenEnbez != null ? anlagenEnbez + " " : "") + anlagenNummer.group(1); normTitel = null; } else if (neueNorm) { normEnbez = normKopf.group(1) + " " + normKopf.group(2); |