start draft of assert struct (with nice debug msgs) + more structure @ par parser

src/paragraph/parser/abschnitt.rs

@@ -0,0 +1,254 @@
+use std::collections::HashMap;
+use std::iter::Peekable;
+
+use roxmltree::{Children, Node};
+
+use crate::law::LawBuilder;
+use crate::paragraph::parser::{
+    Absatz, AbsatzAbs, Content, Fzinhalt, Kzinhalt, Liste, Table, Ueberschrift,
+};
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Abschnitt {
+    metadata: HashMap<String, String>,
+    pub(crate) cont: bool,
+}
+
+impl Default for Abschnitt {
+    fn default() -> Self {
+        Self {
+            metadata: HashMap::new(),
+            cont: false,
+        }
+    }
+}
+
+impl Abschnitt {
+    pub(crate) fn parse(n: Node, builder: &mut LawBuilder) -> Abschnitt {
+        assert!(n.tag_name().name() == "abschnitt");
+
+        let mut ret = Abschnitt::default();
+        let mut c = n.children().peekable();
+
+        Self::skip_static_fields(&mut c);
+
+        if !ret.handle_headers(&mut c, builder) {
+            return ret;
+        }
+
+        while let Some(child) = c.peek() {
+            // Shciffahrtsgesetz: stop @ anlagen (for now)
+            if Ueberschrift::test(child, "anlage") {
+                return ret;
+            }
+            if Ueberschrift::test(child, "g1") {
+                let ueberschrift = Ueberschrift::parse(c.next().unwrap(), "g1");
+                if ueberschrift.content.trim().starts_with("Artikel") {
+                    return ret;
+                }
+                builder.new_header(&ueberschrift.content);
+            } else if Ueberschrift::test(child, "g2") {
+                let ueberschrift = Ueberschrift::parse(c.next().unwrap(), "g2");
+                builder.new_desc(&ueberschrift.content);
+            } else if Ueberschrift::test(child, "g1min") {
+                let ueberschrift = Ueberschrift::parse(c.next().unwrap(), "g1min");
+                builder.new_header(&ueberschrift.content);
+            } else if Ueberschrift::test(child, "art") {
+                let ueberschrift = Ueberschrift::parse(c.next().unwrap(), "art");
+                if ueberschrift.content.trim().starts_with("Artikel") {
+                    return ret;
+                }
+            } else {
+                break;
+            }
+        }
+
+        if let Some(child) = c.peek() {
+            if Ueberschrift::test(child, "para") {
+                builder
+                    .new_next_para_header(&Ueberschrift::parse(c.next().unwrap(), "para").content);
+            }
+        }
+        // e.g. § 405 abgb has two para (of diseased paragraph)
+        if let Some(child) = c.peek() {
+            if Ueberschrift::test(child, "para") {
+                builder
+                    .new_next_para_header(&Ueberschrift::parse(c.next().unwrap(), "para").content);
+            }
+        }
+
+        // We have 2 tasks
+        // 1) Get paragraph id
+        // 2) Get content
+
+        let mut absatze = Vec::new();
+        let absatz = AbsatzAbs::parse(c.next().expect("We need at least one 'Absatz'"));
+        let par_id = absatz
+            .gldsym
+            .clone()
+            .expect("First 'Absatz' needs to have § id");
+
+        // If there's a  "liste" after an "absatz", the "liste" should be part of the "absatz"
+        if let Some(child) = c.peek() {
+            if Liste::test(child) {
+                let liste = Liste::parse(c.next().unwrap());
+                let mut to_add = vec![Content::Text(absatz.content), liste.get_content()];
+                if let Some(subchild) = c.peek() {
+                    if Absatz::test_with_typ(subchild, "satz") {
+                        // After a 'liste' there can be a '<absatz typ="satz"' which should be part of the list
+                        // (e.g. 85 StGB)
+                        to_add.push(Content::Text(Absatz::parse(c.next().unwrap()).content));
+                    }
+                }
+                absatze.push(Content::List(to_add));
+            } else if Table::test(child) {
+                // If there's a  "table" after an "absatz", the "table" should be part of the "absatz"
+                let table = Table::parse(c.next().unwrap());
+                if let Some(child) = c.peek() {
+                    if Absatz::test_with_typ(child, "erltext") {
+                        let after_absatz = Absatz::parse(c.next().unwrap());
+                        absatze.push(Content::List(vec![
+                            Content::Text(absatz.content),
+                            Content::List(table.get_list()),
+                            Content::Text(after_absatz.content),
+                        ]));
+                    } else {
+                        absatze.push(Content::List(vec![
+                            Content::Text(absatz.content),
+                            Content::List(table.get_list()),
+                        ]));
+                    }
+                }
+            } else if Absatz::test_with_typ(child, "satz") {
+                // After a 'liste' there can be a '<absatz typ="satz"' which should be part of the list
+                // (e.g. 1209 ABGB)
+                absatze.push(Content::List(vec![
+                    Content::Text(absatz.content.clone()),
+                    Content::Text(Absatz::parse(c.next().unwrap()).content),
+                ]));
+            } else {
+                absatze.push(Content::Text(absatz.content.clone()));
+            }
+        } else {
+            absatze.push(Content::Text(absatz.content.clone()));
+        }
+
+        //There can be as many 'Absätze' as our lovely lawsetter wants
+        while let Some(child) = c.peek() {
+            if AbsatzAbs::test(child) {
+                let abs = AbsatzAbs::parse(c.next().unwrap());
+
+                // If there's a  "liste" after an "absatz", the "liste" should be part of the "absatz"
+                if let Some(child) = c.peek() {
+                    if Liste::test(child) {
+                        let liste = Liste::parse(c.next().unwrap());
+                        let mut to_add = vec![Content::Text(abs.content), liste.get_content()];
+                        if let Some(subchild) = c.peek() {
+                            if Absatz::test_with_typ(subchild, "satz") {
+                                // After a 'liste' there can be a '<absatz typ="satz"' which should be part of the list
+                                // (e.g. 85 StGB)
+                                to_add
+                                    .push(Content::Text(Absatz::parse(c.next().unwrap()).content));
+                            }
+                        }
+                        absatze.push(Content::List(to_add));
+                    } else {
+                        let mut content = abs.content;
+                        while let Some(subchild) = c.peek() {
+                            if Absatz::test_with_typ(subchild, "erltext") {
+                                content += &Absatz::parse(c.next().unwrap()).content;
+                            } else {
+                                break;
+                            }
+                        }
+                        absatze.push(Content::Text(content));
+                    }
+                } else {
+                    absatze.push(Content::Text(abs.content));
+                }
+                continue;
+            }
+            break;
+        }
+
+        if absatze.len() == 1 {
+            builder.new_par(par_id, absatze[0].clone());
+        } else {
+            let mut contents = Vec::new();
+            for a in &absatze {
+                contents.push(a.clone());
+            }
+            builder.new_par(par_id, Content::Item(contents));
+        }
+
+        // Skip all UeberschriftTitle and Absatz
+        while let Some(child) = c.peek() {
+            if Ueberschrift::test(child, "titel") {
+                c.next();
+                continue;
+            }
+            if Absatz::test_with_typ(child, "erltext") {
+                c.next();
+                continue;
+            }
+            break;
+        }
+
+        assert_eq!(c.next(), None);
+
+        ret.cont = true;
+        ret
+    }
+
+    // There are paragraph-specific meta-data at the top of each xml file. We parse those. When we
+    // encounter the title "Text" the real content starts, we stop parsing meta data.
+    //
+    // # Returns
+    // `false` if the parsing should be stopped
+    fn handle_headers(&mut self, c: &mut Peekable<Children>, builder: &mut LawBuilder) -> bool {
+        while let Some(child) = &c.peek() {
+            if Ueberschrift::test(child, "titel") {
+                let key = Ueberschrift::parse(c.next().unwrap(), "titel").content;
+
+                // We are done with meta-data parsing
+                if key == "Text" {
+                    break;
+                }
+
+                let absatz = Absatz::parse(
+                    c.next()
+                        .expect("Expected absatz after title in par headers"),
+                );
+                if &absatz.typ != "erltext" {
+                    panic!(
+                        "Expected erlext absatz after title in par headers, got '{}'",
+                        absatz.typ
+                    );
+                }
+                let value = absatz.content;
+
+                // We want ot use this information in our markdown output.
+                // TODO: Use all metadata, instead of this specific call
+                if key == "Beachte" {
+                    builder.add_next_para_note(value.clone());
+                }
+
+                self.metadata.insert(key, value);
+                continue;
+            }
+
+            panic!("Something unforeseen happened")
+        }
+        true
+    }
+
+    // At the beginning of each 'Abschnitt' there are 4 static fields. Since they don't provide any
+    // value, we skip them with this function.
+    // If they are not there, we panic (unwrap), as we should take a look why they changed that.
+    fn skip_static_fields(node: &mut Peekable<Children>) {
+        Kzinhalt::parse(node.next().unwrap()); // "Bundesrecht konsolidiert"
+        Kzinhalt::parse(node.next().unwrap()); // "Bundesrecht konsolidiert"
+        Fzinhalt::parse(node.next().unwrap()); // "www.ris.bka.gv.at" and "Seite X von Y"
+        Fzinhalt::parse(node.next().unwrap()); // "www.ris.bka.gv.at" and "Seite X von Y"
+    }
+}

src/paragraph/parser/mod.rs

@@ -0,0 +1,455 @@
+// Copyright (C) 2024 Philipp Hofer
+//
+// Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
+// the European Commission - subsequent versions of the EUPL (the "Licence").
+// You may not use this work except in compliance with the Licence.
+//
+// You should have received a copy of the European Union Public License along
+// with this program.  If not, you may obtain a copy of the Licence at:
+// <https://joinup.ec.europa.eu/software/page/eupl>
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Licence is distributed on an "AS IS" basis,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the Licence for the specific language governing permissions and
+// limitations under the Licence.
+
+mod abschnitt;
+
+use abschnitt::Abschnitt;
+use roxmltree::Node;
+
+use crate::{
+    law::{Content, LawBuilder},
+    misc::Error,
+};
+
+struct Expect<'a> {
+    node: &'a Node<'a, 'a>,
+}
+
+impl<'a> From<&'a Node<'a, 'a>> for Expect<'a> {
+    fn from(node: &'a Node<'a, 'a>) -> Self {
+        Expect { node }
+    }
+}
+
+impl<'a> Expect<'a> {
+    fn tag(&self, value: &str) {
+        if self.node.tag_name().name() != value {
+            panic!(
+                "Expected tag '{value}', got {} (tag: {}, content: {:?})",
+                self.node.tag_name().name(),
+                self.node.tag_name().name(),
+                self.node.text(),
+            );
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Risdok {}
+
+impl Risdok {
+    pub(crate) fn parse(n: Node, builder: &mut LawBuilder) -> bool {
+        assert!(n.tag_name().name() == "risdok");
+
+        let mut c = n.children();
+
+        Metadaten::parse(c.next().unwrap());
+        let nutzdaten = Nutzdaten::parse(c.next().unwrap(), builder);
+        if !nutzdaten {
+            return false;
+        }
+        Layoutdaten::parse(c.next().unwrap());
+
+        assert_eq!(c.next(), None);
+
+        true
+    }
+
+    pub(crate) fn from_str(xml: &str, builder: &mut LawBuilder) -> Result<bool, Error> {
+        let doc = roxmltree::Document::parse(xml)?;
+        let root = doc.root();
+        assert_eq!(root.children().count(), 1);
+        Ok(Self::parse(root.children().next().unwrap(), builder))
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Metadaten;
+impl Metadaten {
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(n.tag_name().name() == "metadaten");
+
+        assert_eq!(n.children().next(), None);
+
+        Self {}
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Nutzdaten {}
+impl Nutzdaten {
+    pub(crate) fn parse(n: Node, builder: &mut LawBuilder) -> bool {
+        assert!(n.tag_name().name() == "nutzdaten");
+
+        let mut c = n.children();
+
+        let ret = Abschnitt::parse(c.next().unwrap(), builder);
+
+        assert_eq!(c.next(), None);
+
+        ret.cont
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub(crate) struct Symbol {
+    stellen: String,
+    content: String,
+}
+impl Symbol {
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(n.tag_name().name() == "symbol");
+        assert_eq!(n.children().count(), 1);
+
+        let stellen = n.attribute("stellen").unwrap().into();
+        let content = n.text().unwrap().into();
+
+        Self { stellen, content }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub(crate) struct Listelem {
+    symbol: Symbol,
+    text: String,
+}
+impl Listelem {
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(n.tag_name().name() == "listelem");
+
+        let mut c = n.children();
+
+        let symbol = Symbol::parse(c.next().unwrap());
+
+        let text = c.next().unwrap().text().unwrap().into();
+
+        assert_eq!(c.next(), None);
+
+        Self { symbol, text }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub(crate) struct Ziffernliste {
+    ebene: String,
+    listelems: Vec<Listelem>,
+}
+impl Ziffernliste {
+    pub(crate) fn test(n: &Node) -> bool {
+        // strichliste -> § 194b FSG
+        ["ziffernliste", "aufzaehlung", "literaliste", "strichliste"].contains(&n.tag_name().name())
+    }
+
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(Self::test(&n));
+
+        let ebene = n.attribute("ebene").unwrap().into();
+
+        let mut listelems = Vec::new();
+
+        for child in n.children() {
+            listelems.push(Listelem::parse(child));
+        }
+
+        Self { ebene, listelems }
+    }
+
+    pub(crate) fn get_content(&self) -> Content {
+        let mut elems = Vec::new();
+
+        for elem in &self.listelems {
+            elems.push(Content::Text(format!(
+                "{} {}",
+                elem.symbol.content, elem.text
+            )));
+        }
+
+        Content::List(elems)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Td {
+    absatz: Absatz,
+}
+impl Td {
+    pub(crate) fn parse(n: &Node) -> Self {
+        assert!(n.tag_name().name() == "td");
+
+        let mut c = n.children();
+        let absatz = Absatz::parse(c.next().unwrap());
+
+        assert_eq!(c.next(), None);
+
+        Self { absatz }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Tr {
+    tds: Vec<Td>,
+}
+impl Tr {
+    pub(crate) fn parse(n: &Node) -> Self {
+        assert!(n.tag_name().name() == "tr");
+
+        let mut tds = Vec::new();
+
+        for child in n.children() {
+            tds.push(Td::parse(&child));
+        }
+
+        Self { tds }
+    }
+}
+#[derive(Debug, PartialEq)]
+pub(crate) struct Table {
+    trs: Vec<Tr>,
+}
+impl Table {
+    pub(crate) fn test(n: &Node) -> bool {
+        n.tag_name().name() == "table"
+    }
+
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(Self::test(&n));
+        let mut trs = Vec::new();
+
+        for child in n.children() {
+            trs.push(Tr::parse(&child));
+        }
+
+        Self { trs }
+    }
+
+    pub(crate) fn get_list(&self) -> Vec<Content> {
+        let mut ret = Vec::new();
+
+        for tr in &self.trs {
+            let mut txt = String::new();
+            for td in &tr.tds {
+                txt.push_str(&format!("{} ", td.absatz.content));
+            }
+
+            ret.push(Content::Text(format!("- {txt}",)));
+        }
+
+        ret
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Schlussteil {
+    content: String,
+}
+impl Schlussteil {
+    pub(crate) fn test(n: &Node) -> bool {
+        (n.tag_name().name() == "schlussteil" || n.tag_name().name() == "schluss")
+            && n.children().count() == 1
+    }
+
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(Self::test(&n));
+
+        let content = n.children().next().unwrap().text().unwrap().into(); //not sure
+
+        Self { content }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Liste {
+    content: Vec<Content>,
+}
+impl Liste {
+    pub(crate) fn test(n: &Node) -> bool {
+        n.tag_name().name() == "liste"
+    }
+
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(Self::test(&n));
+
+        let mut content = Vec::new();
+
+        let mut c = n.children().peekable();
+
+        // 162 Schifffahrtsgesetz show use that a 'schlussteil' can be at the start of a list
+        while let Some(child) = c.peek() {
+            if Schlussteil::test(child) {
+                content.push(Content::Text(Schlussteil::parse(c.next().unwrap()).content));
+            } else {
+                break;
+            }
+        }
+
+        content.push(Ziffernliste::parse(c.next().unwrap()).get_content());
+
+        while let Some(child) = c.peek() {
+            if Ziffernliste::test(child) {
+                content.push(Ziffernliste::parse(c.next().unwrap()).get_content());
+            } else if Schlussteil::test(child) {
+                content.push(Content::Text(Schlussteil::parse(c.next().unwrap()).content));
+            } else {
+                break;
+            }
+        }
+
+        assert_eq!(c.next(), None);
+
+        Self { content }
+    }
+
+    pub(crate) fn get_content(&self) -> Content {
+        Content::List(self.content.clone())
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct AbsatzAbs {
+    gldsym: Option<String>,
+    content: String,
+}
+impl AbsatzAbs {
+    pub(crate) fn test(n: &Node) -> bool {
+        n.tag_name().name() == "absatz" && n.attribute("typ").unwrap() == "abs"
+    }
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(Self::test(&n));
+
+        let mut c = n.children().peekable();
+
+        let gldsym = match c.peek() {
+            Some(child) => {
+                if Leaf::test(child, "gldsym") {
+                    Some(Leaf::parse(c.next().unwrap(), "gldsym"))
+                } else {
+                    None
+                }
+            }
+            None => None,
+        };
+
+        let ret = Self {
+            gldsym,
+            content: c.next().unwrap().text().unwrap().trim().into(),
+        };
+
+        assert_eq!(c.next(), None);
+
+        ret
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Leaf {
+    content: String,
+}
+impl Leaf {
+    pub(crate) fn test(n: &Node, name: &str) -> bool {
+        n.tag_name().name() == name && n.children().count() == 1
+    }
+    pub(crate) fn parse(n: Node, name: &str) -> String {
+        assert!(n.tag_name().name() == name);
+
+        assert_eq!(n.children().count(), 1);
+
+        n.text().unwrap().into()
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Absatz {
+    content: String,
+    typ: String,
+}
+impl Absatz {
+    pub(crate) fn test_with_typ(n: &Node, typ: &str) -> bool {
+        n.tag_name().name() == "absatz" && n.attribute("typ") == Some(typ)
+    }
+
+    pub(crate) fn parse(n: Node) -> Self {
+        Expect::from(&n).tag("absatz");
+
+        if let Some(text) = n.text() {
+            Self {
+                content: text.into(),
+                typ: n.attribute("typ").unwrap().into(),
+            }
+        } else {
+            Self {
+                content: String::new(),
+                typ: n.attribute("typ").unwrap().into(),
+            }
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Ueberschrift {
+    typ: String,
+    content: String,
+}
+impl Ueberschrift {
+    fn test(n: &Node, typ: &str) -> bool {
+        n.tag_name().name() == "ueberschrift" && n.attribute("typ").unwrap() == typ
+    }
+    fn test_with_typ_and_content(n: &Node, typ: &str, content: &str) -> bool {
+        Self::test(n, typ) && n.text().unwrap() == content
+    }
+
+    pub(crate) fn parse(n: Node, typ: &str) -> Self {
+        assert!(n.tag_name().name() == "ueberschrift");
+
+        assert_eq!(n.attribute("typ").unwrap(), typ);
+
+        Self {
+            content: n.text().unwrap().into(),
+            typ: typ.into(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Kzinhalt;
+impl Kzinhalt {
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(n.tag_name().name() == "kzinhalt");
+        //TODO parse if necessary
+        Self {}
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Fzinhalt;
+impl Fzinhalt {
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(n.tag_name().name() == "fzinhalt");
+        //TODO parse if necessary
+        Self {}
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct Layoutdaten;
+impl Layoutdaten {
+    pub(crate) fn parse(n: Node) -> Self {
+        assert!(n.tag_name().name() == "layoutdaten");
+
+        assert_eq!(n.children().next(), None);
+
+        Self {}
+    }
+}