Rheinland-Pfalz kennt den Strichpunkt und die Einleitung

Von den drei benannten Idiom-Grenzen des rheinland-pfälzischen Falles fallen zwei.

Die erste: „In Satz 2 wird der Punkt durch einen Strichpunkt ersetzt und
folgender Halbsatz angefügt: „…““. Zwei Neuerungen in einem Satz. „Strichpunkt“
ist die deutsche Nebenform des Semikolons und tritt zu den Satzzeichen-Mustern
hinzu — als Subjekt wie als Ziel, ohne eine einzige neue Gruppe, damit die
hartkodierten Gruppennummern des Erkenners unberührt bleiben. Der Halbsatz wird
eine eigene Ebene der Anfügung. Er beginnt keinen neuen Satz, sondern setzt den
bestehenden hinter dem Strichpunkt fort; angefügt wird er deshalb nur, wenn der
Zieltext tatsächlich auf einen Strichpunkt endet. Sonst stünde er hinter einem
Punkt und wäre gerade kein Halbsatz. Als Ziel einer Struktur-Einfügung oder
-Ersetzung bleibt er ausgeschlossen: Welche Hälfte eines Satzes gemeint wäre,
sagt keine Bezeichnung. Die Verbundmechanik selbst brauchte keinen Eingriff.

Die zweite: „In der Einleitung werden die Worte „…“ durch die Angabe „…“
ersetzt.“ Das ist ein Chapeau-Lokator wie „im Satzteil vor Nummer 1“, nur ohne
Bezugspunkt; er tritt als zweite Alternative zum vorhandenen Muster. Eine echte
Verengung auf den Satzteil vor der ersten Marke wäre eine eigene
Stellenkomponente und ist es nicht: Kommt der Zieltext außer im Chapeau auch in
einer Nummer vor, so meldet die Auflösung Mehrdeutigkeit — der richtige Ausgang.

Dass beide Befehle am rheinland-pfälzischen Stamm gleichwohl nicht greifen, liegt
an der Quelle und nicht am Werkzeug: Das Portal führt keine früheren
Gesamtausgaben, der Stamm ist hier die Nachfassung, und ihr Wortlaut trägt die
Änderung bereits.

Offen bleibt die dritte Grenze, die Verweisung auf einen anderen Punkt desselben
Artikels.

Geprüft: 386 Tests (zuvor 381).

Change-Id: I993d8645fba1c933ad8497ca175cef265df2c0b0

4 files changed, 145 insertions, 9 deletions

diff --git a/src/test/java/eu/mulk/aendggner/EndToEndTest.java b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
index 41f30e5..d0273ad 100644
--- a/src/test/java/eu/mulk/aendggner/EndToEndTest.java
+++ b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
@@ -6,6 +6,8 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Ersetzung;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Sammelbefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.StrukturEinfuegung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.UnbekannterBefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortAnker;
@@ -1878,20 +1880,31 @@ class EndToEndTest {
             .filter(b -> b.provenienz().originalText().contains("die Worte"))
             .toList();
     assertThat(wortbefehle).hasSizeGreaterThanOrEqualTo(7);
-    assertThat(wortbefehle).filteredOn(b -> b instanceof UnbekannterBefehl).hasSize(1);
-
-    // Drei benannte Idiom-Grenzen, alle im Wortlaut festgehalten:
-    //   5. a) aa) — Satzzeichen-Ersetzung im Verbund mit einer Halbsatz-Anfügung („wird der Punkt
-    //     durch einen Strichpunkt ersetzt und folgender Halbsatz angefügt“).
-    //   7. a) aa) — „In der Einleitung“ als Ziel, also der Chapeau eines Satzes mit Nummern.
-    //   12. — die Verweisung auf einen anderen Punkt desselben Artikels („Die Inhaltsübersicht wird
-    //     entsprechend der vorstehenden Nummer 8 Buchst. a geändert“).
+    assertThat(wortbefehle).noneMatch(b -> b instanceof UnbekannterBefehl);
+
+    // Der Strichpunkt-Verbund („wird der Punkt durch einen Strichpunkt ersetzt und folgender
+    // Halbsatz angefügt“) und der bezugspunktlose Chapeau („In der Einleitung“) werden gelesen;
+    // dass beide gleichwohl nicht greifen, liegt an der Quelle und nicht am Werkzeug: Der Stamm
+    // ist hier die Nachfassung, ihr Wortlaut trägt die Änderung bereits.
+    assertThat(befehlAn(parseErgebnis, "5. a) aa)")).isInstanceOf(Sammelbefehl.class);
+    assertThat(befehlAn(parseErgebnis, "7. a) aa)")).isInstanceOf(Ersetzung.class);
+
+    // Eine benannte Grenze bleibt: die Verweisung auf einen anderen Punkt desselben Artikels
+    // („Die Inhaltsübersicht wird entsprechend der vorstehenden Nummer 8 Buchst. a geändert“).
     var unerkannt =
         parseErgebnis.befehle().stream()
             .filter(b -> b instanceof UnbekannterBefehl)
             .map(b -> b.provenienz().gliederungsPfad())
             .toList();
-    assertThat(unerkannt).containsExactly("5. a) aa)", "7. a) aa)", "12.");
+    assertThat(unerkannt).containsExactly("12.");
+  }
+
+  private static Aenderungsbefehl befehlAn(
+      AenderungsgesetzParser.ParseErgebnis ergebnis, String gliederungsPfad) {
+    return ergebnis.befehle().stream()
+        .filter(b -> gliederungsPfad.equals(b.provenienz().gliederungsPfad()))
+        .findFirst()
+        .orElseThrow();
   }
 
   /**
diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java
index 7742a3a..80234b8 100644
--- a/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java
@@ -1473,4 +1473,45 @@ class BefehlErkennerTest {
     assertThat(BefehlErkenner.erkenne(text, Stelle.LEER, zitate, PROV))
         .containsInstanceOf(Ersetzung.class);
   }
+
+  /**
+   * Rheinland-Pfalz: „In Satz 2 wird der Punkt durch einen Strichpunkt ersetzt und folgender
+   * Halbsatz angefügt: „…““. Zwei Neuerungen in einem Satz — der Strichpunkt als deutsche Nebenform
+   * des Semikolons und der Halbsatz als Ebene der Anfügung. Die Verbundmechanik selbst bestand
+   * bereits.
+   */
+  @Test
+  void erkenntStrichpunktErsetzungMitHalbsatzAnfuegung() {
+    var befehl =
+        erkenne(
+            "In Satz 2 wird der Punkt durch einen Strichpunkt ersetzt und folgender Halbsatz"
+                + " angefügt: „die Bearbeitungszeit der Abschlussarbeit zählt zu den"
+                + " Fachstudien.“",
+            new Stelle(List.of(new Stelle.Paragraph("8"), new Stelle.AbsatzNr("1"))));
+
+    assertThat(befehl).containsInstanceOf(Sammelbefehl.class);
+    var teile = ((Sammelbefehl) befehl.orElseThrow()).teilbefehle();
+    assertThat(teile).hasSize(2);
+
+    assertThat(teile.get(0)).isInstanceOf(Ersetzung.class);
+    var ersetzung = (Ersetzung) teile.get(0);
+    assertThat(ersetzung.alt()).isEqualTo(".");
+    assertThat(ersetzung.neu()).isEqualTo(";");
+    assertThat(ersetzung.stelle().anzeigeText()).isEqualTo("§ 8 Absatz 1 Satz 2");
+
+    assertThat(teile.get(1)).isInstanceOf(Anfuegung.class);
+    var anfuegung = (Anfuegung) teile.get(1);
+    assertThat(anfuegung.ebene()).isEqualTo(Ebene.HALBSATZ);
+    assertThat(anfuegung.text()).contains("die Bearbeitungszeit der Abschlussarbeit");
+  }
+
+  /** Der Strichpunkt gilt auch als Subjekt („Der Strichpunkt wird durch ein Komma ersetzt“). */
+  @Test
+  void erkenntDenStrichpunktAlsSubjekt() {
+    var befehl = erkenne("Der Strichpunkt am Ende wird durch ein Komma ersetzt.", PARAGRAPH_5);
+    assertThat(befehl).containsInstanceOf(Ersetzung.class);
+    var ersetzung = (Ersetzung) befehl.orElseThrow();
+    assertThat(ersetzung.alt()).isEqualTo(";");
+    assertThat(ersetzung.neu()).isEqualTo(",");
+  }
 }
diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java
index ee7e5c7..13e4442 100644
--- a/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java
@@ -138,4 +138,18 @@ class StellenParserTest {
             StellenParser.parse("Absatz 1 in der Angabe vor Nummer 1").orElseThrow().anzeigeText())
         .isEqualTo("Absatz 1");
   }
+
+  /**
+   * „In der Einleitung“ (Rheinland-Pfalz) ist ein Chapeau-Lokator wie „im Satzteil vor Nummer 1“:
+   * Er nennt keinen Bezugspunkt und trägt deshalb keine eigene Komponente — die Operation läuft auf
+   * der Stelle, die der Rahmen bezeichnet.
+   */
+  @Test
+  void einleitungIstEinChapeauLokator() {
+    assertThat(StellenParser.istNurChapeau("In der Einleitung")).isTrue();
+    assertThat(StellenParser.istNurChapeau("Im Eingangssatz")).isTrue();
+    assertThat(StellenParser.istNurChapeau("in dem Einleitungssatz")).isTrue();
+    // Ein Wort, das bloß so anfängt, ist keiner.
+    assertThat(StellenParser.istNurChapeau("In der Einleitungsformel")).isFalse();
+  }
 }
diff --git a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
index a1f5cff..39c71cc 100644
--- a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
+++ b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
@@ -1891,4 +1891,72 @@ class BefehlAnwenderTest {
     assertThat(ergebnis.neu().norm("§ 108").orElseThrow().absaetze().get(0).text())
         .doesNotContain("oder Absatz 4");
   }
+
+  /**
+   * Ein Halbsatz setzt den Satz hinter dem Strichpunkt fort; er beginnt keinen neuen. Angefügt wird
+   * er deshalb wie ein Satz — aber nur hinter einem Strichpunkt. Endet der Zieltext auf einen
+   * Punkt, so wäre das Angefügte gerade kein Halbsatz, und der Befehl bleibt liegen.
+   */
+  @Test
+  void halbsatzWirdHinterDemStrichpunktAngefuegt() {
+    var gesetz =
+        new Gesetz(
+            "TestG",
+            "Testgesetz",
+            "TestG",
+            List.of(
+                new Norm(
+                    "§ 8",
+                    null,
+                    null,
+                    List.of(new Absatz("1", "Erster Satz. Der zweite Satz endet hier;")),
+                    false)));
+
+    var befehl =
+        new Anfuegung(
+            stelle(new Stelle.Paragraph("8"), new Stelle.AbsatzNr("1")),
+            Ebene.HALBSATZ,
+            null,
+            "die Bearbeitungszeit zählt zu den Fachstudien.",
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(gesetz, List.of(befehl));
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(ergebnis.neu().norm("§ 8").orElseThrow().absaetze().get(0).text())
+        .isEqualTo(
+            "Erster Satz. Der zweite Satz endet hier; die Bearbeitungszeit zählt zu den"
+                + " Fachstudien.");
+  }
+
+  @Test
+  void halbsatzOhneStrichpunktBleibtLiegen() {
+    var gesetz =
+        new Gesetz(
+            "TestG",
+            "Testgesetz",
+            "TestG",
+            List.of(
+                new Norm(
+                    "§ 8",
+                    null,
+                    null,
+                    List.of(new Absatz("1", "Erster Satz. Der zweite Satz endet hier.")),
+                    false)));
+
+    var befehl =
+        new Anfuegung(
+            stelle(new Stelle.Paragraph("8"), new Stelle.AbsatzNr("1")),
+            Ebene.HALBSATZ,
+            null,
+            "die Bearbeitungszeit zählt zu den Fachstudien.",
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(gesetz, List.of(befehl));
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.MANUELL_PRUEFEN);
+    assertThat(ergebnis.protokoll().get(0).grund()).isEqualTo(Grund.BESTAND_WIDERSPRICHT);
+    assertThat(ergebnis.protokoll().get(0).begruendung())
+        .contains("setzt einen Strichpunkt voraus");
+    assertThat(ergebnis.neu().norm("§ 8").orElseThrow().absaetze().get(0).text())
+        .isEqualTo("Erster Satz. Der zweite Satz endet hier.");
+  }
 }