Merge pull request #2194 from strictdoc-project/stanislaw/merge_nodes

backend/sdoc, UI: enable composite requirements adding

Author: stanislaw

strictdoc/backend/excel/import_/excel_to_sdoc_converter.py

@@ -149,7 +149,11 @@ def create_document(
             )
 
         requirements_element = GrammarElement(
-            parent=None, tag="REQUIREMENT", fields=fields, relations=[]
+            parent=None,
+            tag="REQUIREMENT",
+            property_is_composite="",
+            fields=fields,
+            relations=[],
         )
         elements = [requirements_element]
         grammar = DocumentGrammar(parent=document, elements=elements)

strictdoc/backend/reqif/p01_sdoc/reqif_to_sdoc_converter.py

@@ -313,6 +313,9 @@ def create_grammar_element_from_spec_object_type(
         requirement_element = GrammarElement(
             parent=None,
             tag=create_safe_requirement_tag_string(spec_object_type.long_name),
+            # FIXME: MERGE NODES
+            #        When the migration is done, make the nodes to be always recursive.
+            property_is_composite="",
             fields=fields,
             relations=[],
         )

strictdoc/backend/sdoc/grammar/grammar.py

@@ -185,7 +185,7 @@
     (relations += Reference)
   )?
 
-  requirements *= SpaceThenRequirement
+  section_contents *= SpaceThenRequirement
 
   '\n'
   '[[/' node_type_close = RequirementType ']]' '\n'

strictdoc/backend/sdoc/grammar/grammar_grammar.py

@@ -15,6 +15,10 @@
 
 GrammarElement[noskipws]:
   '- TAG: ' tag = RequirementType '\n'
+  (
+    '  PROPERTIES:' '\n'
+    '    IS_COMPOSITE: ' property_is_composite=/(True|False)/ '\n'
+  )?
   '  FIELDS:' '\n'
   fields += GrammarElementField
   (

strictdoc/backend/sdoc/models/document_grammar.py

@@ -46,6 +46,7 @@ def __init__(
         self,
         parent,
         tag: str,
+        property_is_composite: str,
         fields: List[
             Union[
                 GrammarElementFieldString,
@@ -57,6 +58,13 @@ def __init__(
     ):
         self.parent = parent
         self.tag: str = tag
+
+        assert property_is_composite in ("", "True", "False")
+        self.property_is_composite: Optional[bool] = (
+            None
+            if property_is_composite == ""
+            else (property_is_composite == "True")
+        )
         self.fields: List[
             Union[
                 GrammarElementFieldString,
@@ -102,6 +110,7 @@ def create_default(tag: str):
         return GrammarElement(
             parent=None,
             tag=tag,
+            property_is_composite="",
             fields=[
                 GrammarElementFieldString(
                     parent=None,
@@ -271,7 +280,11 @@ def create_default(parent) -> "DocumentGrammar":
             ),
         ]
         requirement_element = GrammarElement(
-            parent=None, tag="REQUIREMENT", fields=fields, relations=[]
+            parent=None,
+            tag="REQUIREMENT",
+            property_is_composite="",
+            fields=fields,
+            relations=[],
         )
         # @relation(SDOC-SRS-132, scope=range_end)
 
@@ -346,7 +359,11 @@ def create_for_test_report(parent) -> "DocumentGrammar":
             ),
         ]
         requirement_element = GrammarElement(
-            parent=None, tag="TEST_RESULT", fields=fields, relations=[]
+            parent=None,
+            tag="TEST_RESULT",
+            property_is_composite="",
+            fields=fields,
+            relations=[],
         )
 
         requirement_element.relations = create_default_relations(
@@ -440,7 +457,11 @@ def create_default_text_element(parent=None) -> GrammarElement:
             ),
         ]
         text_element = GrammarElement(
-            parent=parent, tag="TEXT", fields=fields, relations=[]
+            parent=parent,
+            tag="TEXT",
+            property_is_composite="",
+            fields=fields,
+            relations=[],
         )
         return text_element
 

strictdoc/backend/sdoc/models/model.py

@@ -13,6 +13,7 @@ class SDocNodeFieldIF(ABC):
 class SDocNodeIF(ABC):
     node_type: str
     ng_resolved_custom_level: Optional[str]
+    section_contents: List["SDocSectionContentIF"]
 
     @abstractmethod
     def is_normative_node(self) -> bool:
@@ -38,15 +39,15 @@ def get_including_document(self) -> Optional["SDocDocumentIF"]:
     def get_parent_or_including_document(self) -> "SDocDocumentIF":
         raise NotImplementedError  # pragma: no cover
 
-
-class SDocCompositeNodeIF(SDocNodeIF):
-    section_contents: List["SDocSectionContentIF"]
-
     @abstractmethod
     def get_requirement_prefix(self) -> str:
         raise NotImplementedError  # pragma: no cover
 
 
+class SDocCompositeNodeIF(SDocNodeIF, ABC):
+    pass
+
+
 class SDocSectionIF(ABC):
     parent: Union["SDocDocumentIF", "SDocSectionIF"]
     ng_resolved_custom_level: Optional[str]

strictdoc/backend/sdoc/models/node.py

@@ -16,6 +16,7 @@
     SDocCompositeNodeIF,
     SDocDocumentIF,
     SDocNodeIF,
+    SDocSectionContentIF,
     SDocSectionIF,
 )
 from strictdoc.backend.sdoc.models.reference import (
@@ -108,6 +109,7 @@ def __init__(
         relations: List[Reference],
         is_composite: bool = False,
         requirements: Optional[List["SDocNode"]] = None,
+        section_contents: Optional[List[SDocSectionContentIF]] = None,
         node_type_close: Optional[str] = None,
     ) -> None:
         assert parent
@@ -137,6 +139,9 @@ def __init__(
             ordered_fields_lookup.setdefault(field.field_name, []).append(field)
 
         self.requirements: Optional[List[SDocNode]] = requirements
+        self.section_contents: List[SDocSectionContentIF] = (
+            section_contents if section_contents is not None else []
+        )
 
         self.relations: List[Reference] = relations
 
@@ -511,11 +516,11 @@ def get_field_human_title_for_statement(self) -> str:
         return field_human_title.get_field_human_name()
 
     def get_requirement_prefix(self) -> str:
-        parent: Union[SDocDocumentIF, SDocSectionIF, SDocCompositeNodeIF] = (
-            assert_cast(
-                self.parent,
-                (SDocDocumentIF, SDocSectionIF, SDocCompositeNodeIF),
-            )
+        parent: Union[
+            SDocDocumentIF, SDocSectionIF, SDocNodeIF, SDocCompositeNodeIF
+        ] = assert_cast(
+            self.parent,
+            (SDocDocumentIF, SDocSectionIF, SDocNodeIF, SDocCompositeNodeIF),
         )
         return parent.get_requirement_prefix()
 

strictdoc/backend/sdoc/processor.py

@@ -79,6 +79,7 @@ def process_document_config(self, document_config: DocumentConfig):
 
     def process_document_grammar(self, document_grammar: DocumentGrammar):
         preserve_source_location_data(document_grammar)
+        # FIXME: It would be great to move forward and remove this.
         if not document_grammar.has_text_element():
             document_grammar.add_element_first(
                 DocumentGrammar.create_default_text_element(document_grammar)

strictdoc/backend/sdoc/writer.py

@@ -214,7 +214,17 @@ def write_with_fragments(
                 for element in document_grammar.elements:
                     output += "- TAG: "
                     output += element.tag
-                    output += "\n  FIELDS:\n"
+                    output += "\n"
+
+                    if element.property_is_composite is not None:
+                        output += "  PROPERTIES:\n"
+                        output += "    IS_COMPOSITE: "
+                        output += (
+                            "True" if element.property_is_composite else "False"
+                        )
+                        output += "\n"
+
+                    output += "  FIELDS:\n"
                     for grammar_field in element.fields:
                         output += SDWriter._print_grammar_field_type(
                             grammar_field
@@ -282,7 +292,10 @@ def _print_node(
         elif isinstance(root_node, SDocNode):
             output = ""
 
-            if isinstance(root_node, SDocCompositeNodeNew):
+            if (
+                isinstance(root_node, SDocCompositeNodeNew)
+                or root_node.is_composite
+            ):
                 output += "[["
                 output += root_node.node_type
                 output += "]]\n"
@@ -300,15 +313,31 @@ def _print_node(
             )
             output += "\n"
 
-            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
-                    )
+            if (
+                isinstance(root_node, (SDocCompositeNode, SDocCompositeNodeNew))
+                or root_node.is_composite
+            ):
+                # FIXME: Remove the legacy .requirements.
+                if root_node.requirements is not None:
+                    for node_ in root_node.requirements:
+                        if not node_.ng_whitelisted:
+                            continue
+                        output += self._print_node(
+                            node_, document, document_iterator=document_iterator
+                        )
+
+                if root_node.section_contents is not None:
+                    for node_ in root_node.section_contents:
+                        if not node_.ng_whitelisted:
+                            continue
+                        output += self._print_node(
+                            node_, document, document_iterator=document_iterator
+                        )
 
-                if isinstance(root_node, SDocCompositeNodeNew):
+                if (
+                    isinstance(root_node, SDocCompositeNodeNew)
+                    or root_node.is_composite
+                ):
                     output += "[[/"
                     output += root_node.node_type
                     output += "]]\n"

strictdoc/core/document_iterator.py

@@ -170,6 +170,24 @@ def get_level_string_(
 
             yield node
 
+            current_number = 0
+            if node.section_contents is not None:
+                for subnode_ in node.section_contents:
+                    if subnode_.ng_resolved_custom_level is None and not (
+                        isinstance(subnode_, SDocNode)
+                        and subnode_.node_type == "TEXT"
+                    ):
+                        current_number += 1
+
+                    yield from self._all_content(
+                        subnode_,
+                        print_fragments=print_fragments,
+                        print_fragments_from_files=print_fragments_from_files,
+                        level_stack=level_stack + (current_number,),
+                        custom_level=custom_level
+                        or subnode_.ng_resolved_custom_level is not None,
+                    )
+
         elif isinstance(node, SDocDocument):
             if (
                 print_fragments