backend/sdoc: groundwork for new composite node syntax

Author: stanislaw

strictdoc/backend/sdoc/grammar/grammar.py

@@ -151,7 +151,7 @@
 ;
 
 SectionOrRequirement[noskipws]:
-  '\n' (SDocSection | SDocNode | SDocCompositeNode | DocumentFromFile)
+  '\n' (SDocSection | SDocCompositeNodeNew | SDocNode | SDocCompositeNode | DocumentFromFile)
 ;
 
 DocumentFromFile[noskipws]:
@@ -176,6 +176,21 @@
   )?
 ;
 
+SDocCompositeNodeNew[noskipws]:
+  '[[' node_type = RequirementType ']]' '\n'
+
+  fields *= SDocNodeField
+  (
+    'RELATIONS:' '\n'
+    (relations += Reference)
+  )?
+
+  requirements *= SpaceThenRequirement
+
+  '\n'
+  '[[/' node_type_close = RequirementType ']]' '\n'
+;
+
 SDocCompositeNodeTagName[noskipws]:
   'COMPOSITE_'
 ;

strictdoc/backend/sdoc/models/constants.py

@@ -13,6 +13,7 @@
 from strictdoc.backend.sdoc.models.inline_link import InlineLink
 from strictdoc.backend.sdoc.models.node import (
     SDocCompositeNode,
+    SDocCompositeNodeNew,
     SDocNode,
     SDocNodeField,
 )
@@ -43,6 +44,7 @@
     SDocNode,
     SDocNodeField,
     SDocCompositeNode,
+    SDocCompositeNodeNew,
     Reference,
     ParentReqReference,
     ChildReqReference,

strictdoc/backend/sdoc/models/node.py

@@ -106,7 +106,9 @@ def __init__(
         node_type: str,
         fields: List[SDocNodeField],
         relations: List[Reference],
+        is_composite: bool = False,
         requirements: Optional[List["SDocNode"]] = None,
+        node_type_close: Optional[str] = None,
     ) -> None:
         assert parent
         assert isinstance(node_type, str)
@@ -117,6 +119,12 @@ def __init__(
         ] = parent
 
         self.node_type: str = node_type
+        # FIXME: MERGE NODES
+        if node_type_close is not None and len(node_type_close) > 0:
+            assert node_type == node_type_close
+            assert is_composite
+
+        self.is_composite: bool = is_composite
 
         ordered_fields_lookup: OrderedDict[str, List[SDocNodeField]] = (
             OrderedDict()
@@ -174,7 +182,9 @@ def __init__(
             self.custom_level = level
 
         # This is always true, unless the node is filtered out with --filter-requirements.
-        self.ng_whitelisted = True
+        self.ng_whitelisted: bool = True
+
+        self.ng_has_requirements: bool = False
 
     @staticmethod
     def get_type_string() -> str:
@@ -646,9 +656,6 @@ def __init__(
         **fields: Any,
     ) -> None:
         super().__init__(parent, **fields)
-        self.ng_document_reference: Optional[DocumentReference] = None
-        self.ng_including_document_reference: Optional[DocumentReference] = None
-        self.ng_has_requirements = False
 
     @property
     def is_composite_requirement(self) -> bool:
@@ -661,9 +668,12 @@ def document(self) -> SDocDocumentIF:
         assert document is not None
         return document
 
-    def document_is_included(self) -> bool:
-        assert self.ng_including_document_reference is not None
-        return self.ng_including_document_reference.get_document() is not None
 
-    def get_requirement_prefix(self) -> str:
-        return self.parent.get_requirement_prefix()
+@auto_described
+class SDocCompositeNodeNew(SDocNode):
+    def __init__(
+        self,
+        parent: Union[SDocDocumentIF, SDocSectionIF, SDocCompositeNodeIF],
+        **fields: Any,
+    ) -> None:
+        super().__init__(parent, **fields, is_composite=True)

strictdoc/backend/sdoc/writer.py

@@ -13,6 +13,7 @@
 )
 from strictdoc.backend.sdoc.models.node import (
     SDocCompositeNode,
+    SDocCompositeNodeNew,
     SDocNode,
 )
 from strictdoc.backend.sdoc.models.reference import (
@@ -37,10 +38,10 @@
 
 
 class SDWriter:
-    def __init__(self, project_config: ProjectConfig):
+    def __init__(self, project_config: ProjectConfig) -> None:
         self.project_config: ProjectConfig = project_config
 
-    def write_to_file(self, document: SDocDocument):
+    def write_to_file(self, document: SDocDocument) -> None:
         document_content, fragments_dict = self.write_with_fragments(document)
 
         document_meta: DocumentMeta = assert_cast(document.meta, DocumentMeta)
@@ -62,7 +63,7 @@ def write_to_file(self, document: SDocDocument):
             with open(path_to_output_fragment, "w", encoding="utf8") as file_:
                 file_.write(fragment_content_)
 
-    def write(self, document: SDocDocument):
+    def write(self, document: SDocDocument) -> str:
         document_output, _ = self.write_with_fragments(document)
         return document_output
 
@@ -281,7 +282,11 @@ def _print_node(
         elif isinstance(root_node, SDocNode):
             output = ""
 
-            if isinstance(root_node, SDocCompositeNode):
+            if isinstance(root_node, SDocCompositeNodeNew):
+                output += "[["
+                output += root_node.node_type
+                output += "]]\n"
+            elif isinstance(root_node, SDocCompositeNode):
                 output += "[COMPOSITE_"
                 output += root_node.node_type
                 output += "]\n"
@@ -295,24 +300,31 @@ def _print_node(
             )
             output += "\n"
 
-            if isinstance(root_node, SDocCompositeNode):
+            if isinstance(root_node, (SDocCompositeNode, SDocCompositeNodeNew)):
                 for node_ in root_node.requirements:
                     if not node_.ng_whitelisted:
                         continue
                     output += self._print_node(
                         node_, document, document_iterator=document_iterator
                     )
 
-                output += "[/COMPOSITE_"
-                output += root_node.node_type
-                output += "]\n"
-                output += "\n"
+                if isinstance(root_node, SDocCompositeNodeNew):
+                    output += "[[/"
+                    output += root_node.node_type
+                    output += "]]\n"
+                    output += "\n"
+                else:
+                    output += "[/COMPOSITE_"
+                    output += root_node.node_type
+                    output += "]\n"
+                    output += "\n"
 
             return output
 
-        raise AssertionError("Must not reach here")
+        raise AssertionError("Must not reach here")  # pragma: no cover
 
-    def _print_document_from_file(self, document_from_file: DocumentFromFile):
+    @staticmethod
+    def _print_document_from_file(document_from_file: DocumentFromFile):
         assert isinstance(document_from_file, DocumentFromFile)
         output = ""
         output += "[DOCUMENT_FROM_FILE]"

tests/unit/strictdoc/backend/sdoc/test_dsl_passthrough_new_composite.py

@@ -0,0 +1,28 @@
+from strictdoc.backend.sdoc.models.document import SDocDocument
+from strictdoc.backend.sdoc.reader import SDReader
+from strictdoc.backend.sdoc.writer import SDWriter
+
+
+def test_001_minimal_doc(default_project_config):
+    input_sdoc = """\
+[DOCUMENT]
+TITLE: Test Doc
+
+[[REQUIREMENT]]
+TITLE: FOO
+
+[REQUIREMENT]
+TITLE: FOO
+
+[[/REQUIREMENT]]
+"""
+
+    reader = SDReader()
+
+    document = reader.read(input_sdoc)
+    assert isinstance(document, SDocDocument)
+
+    writer = SDWriter(default_project_config)
+    output = writer.write(document)
+
+    assert input_sdoc == output