strictdoc 0.0.58__tar.gz → 0.0.59a1__tar.gz

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.58
+Version: 0.0.59a1
 Summary: StrictDoc is open-source software for technical documentation and requirements management.
 Project-URL: Changelog, https://github.com/strictdoc-project/strictdoc/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://strictdoc.readthedocs.io/en/stable/

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/docs_extra/DO178_requirements.sdoc

@@ -10,8 +10,19 @@ OPTIONS:
 
 [GRAMMAR]
 ELEMENTS:
+- TAG: TEXT
+  FIELDS:
+  - TITLE: UID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATEMENT
+    TYPE: String
+    REQUIRED: False
 - TAG: REQUIREMENT
   FIELDS:
+  - TITLE: MID
+    TYPE: String
+    REQUIRED: False
   - TITLE: UID
     TYPE: String
     REQUIRED: False

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/docs_extra/Zephyr_requirements.sdoc

@@ -6,6 +6,43 @@ ROOT: True
 OPTIONS:
   ENABLE_MID: True
 
+[GRAMMAR]
+ELEMENTS:
+- TAG: TEXT
+  FIELDS:
+  - TITLE: UID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATEMENT
+    TYPE: String
+    REQUIRED: False
+- TAG: REQUIREMENT
+  FIELDS:
+  - TITLE: MID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: UID
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATUS
+    TYPE: String
+    REQUIRED: False
+  - TITLE: TITLE
+    TYPE: String
+    REQUIRED: False
+  - TITLE: STATEMENT
+    TYPE: String
+    REQUIRED: False
+  - TITLE: RATIONALE
+    TYPE: String
+    REQUIRED: False
+  - TITLE: COMMENT
+    TYPE: String
+    REQUIRED: False
+  RELATIONS:
+  - TYPE: Parent
+  - TYPE: File
+
 [REQUIREMENT]
 MID: 68e87901205c4b0dbb6a0071479330b5
 UID: ZEP-1

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/requirements.check.txt

@@ -15,7 +15,7 @@ httpx
 
 # Integration tests
 lit>=0.11.0.post1
-filecheck>=0.0.20
+filecheck>=0.0.20,<1.0.0
 pytidylib>=0.3.2
 openpyxl>=3.0.5
 

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.0.58"
+__version__ = "0.0.59a1"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/excel/import_/excel_to_sdoc_converter.py

@@ -215,7 +215,6 @@ class ExcelToSDocConverter:
         requirement = SDocNode(
             parent=template_requirement.parent,
             requirement_type=template_requirement.requirement_type,
-            mid=None,
             fields=list(template_requirement.enumerate_fields()),
             relations=template_requirement.relations,
         )

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/reqif/p01_sdoc/reqif_to_sdoc_converter.py

@@ -1,5 +1,5 @@
 # mypy: disable-error-code="no-untyped-def,union-attr,operator"
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from reqif.models.reqif_data_type import ReqIFDataTypeDefinitionEnumeration
 from reqif.models.reqif_spec_object import ReqIFSpecObject
@@ -34,7 +34,9 @@ from strictdoc.backend.sdoc.models.type_system import (
     GrammarElementFieldMultipleChoice,
     GrammarElementFieldSingleChoice,
     GrammarElementFieldString,
+    GrammarElementRelationParent,
 )
+from strictdoc.helpers.ordered_set import OrderedSet
 from strictdoc.helpers.string import (
     create_safe_requirement_tag_string,
     ensure_newline,
@@ -49,6 +51,12 @@ class P01_ReqIFToSDocBuildContext:
         self.map_spec_object_type_identifier_to_grammar_node_tags: Dict[
             str, GrammarElement
         ] = {}
+        self.map_source_target_pairs_to_spec_relation_types: Dict[
+            Tuple[str, str], Any
+        ] = {}
+        self.unique_grammar_element_relations: Dict[
+            GrammarElement, OrderedSet[Tuple[str, Optional[str]]]
+        ] = {}
 
 
 class P01_ReqIFToSDocConverter:
@@ -69,6 +77,16 @@ class P01_ReqIFToSDocConverter:
         ):
             return []
 
+        for (
+            spec_relation_
+        ) in reqif_bundle.core_content.req_if_content.spec_relations:
+            spec_relation_type_ = reqif_bundle.lookup.get_spec_type_by_ref(
+                spec_relation_.relation_type_ref
+            )
+            context.map_source_target_pairs_to_spec_relation_types[
+                (spec_relation_.source, spec_relation_.target)
+            ] = spec_relation_type_
+
         documents: List[SDocDocument] = []
         for (
             specification
@@ -131,7 +149,9 @@ class P01_ReqIFToSDocConverter:
         # StrictDoc document is not created with irrelevant grammar elements that
         # actually belong to other Specifications in this ReqIF bundle.
         # Using Dict as an ordered set.
-        spec_object_type_identifiers_used_by_this_document: Dict[str, None] = {}
+        spec_object_type_identifiers_used_by_this_document: OrderedSet[str] = (
+            OrderedSet()
+        )
 
         def node_converter_lambda(
             current_hierarchy_,
@@ -140,9 +160,9 @@ class P01_ReqIFToSDocConverter:
             spec_object = reqif_bundle.get_spec_object_by_ref(
                 current_hierarchy_.spec_object
             )
-            spec_object_type_identifiers_used_by_this_document[
+            spec_object_type_identifiers_used_by_this_document.add(
                 spec_object.spec_object_type
-            ] = None
+            )
 
             is_section = P01_ReqIFToSDocConverter.is_spec_object_section(
                 spec_object,
@@ -181,7 +201,7 @@ class P01_ReqIFToSDocConverter:
         elements: List[GrammarElement] = []
         for (
             spec_object_type_identifier_
-        ) in spec_object_type_identifiers_used_by_this_document.keys():
+        ) in spec_object_type_identifiers_used_by_this_document:
             spec_object_type: ReqIFSpecObjectType = (
                 reqif_bundle.lookup.get_spec_type_by_ref(
                     spec_object_type_identifier_
@@ -194,7 +214,13 @@ class P01_ReqIFToSDocConverter:
                     spec_object_type_identifier_
                 ]
             )
+            if len(grammar_element.relations) == 0:
+                grammar_element.relations = create_default_relations(
+                    grammar_element
+                )
+
             elements.append(grammar_element)
+
         grammar: DocumentGrammar
         if len(elements) > 0:
             grammar = DocumentGrammar(parent=document, elements=elements)
@@ -288,9 +314,6 @@ class P01_ReqIFToSDocConverter:
             fields=fields,
             relations=[],
         )
-        requirement_element.relations = create_default_relations(
-            requirement_element
-        )
         return requirement_element
 
     @staticmethod
@@ -382,7 +405,6 @@ class P01_ReqIFToSDocConverter:
             node: SDocNode = SDocNode(
                 parent=section,
                 requirement_type="TEXT",
-                mid=None,
                 fields=[node_field],
                 relations=[],
             )
@@ -465,8 +487,11 @@ class P01_ReqIFToSDocConverter:
             if (
                 "\n" in attribute_value
                 or attribute.attribute_type == SpecObjectAttributeType.XHTML
-                or field_name == ReqIFRequirementReservedField.TEXT
-                or field_name == ReqIFRequirementReservedField.COMMENT_NOTES
+                or field_name
+                in (
+                    ReqIFRequirementReservedField.TEXT,
+                    ReqIFRequirementReservedField.COMMENT_NOTES,
+                )
             ):
                 attribute_value = attribute_value.lstrip()
                 multiline = True
@@ -499,22 +524,67 @@ class P01_ReqIFToSDocConverter:
                 spec_object_type.identifier
             ]
         )
-
+        if requirement_mid is not None:
+            fields.insert(
+                0,
+                SDocNodeField.create_from_string(
+                    None, "MID", requirement_mid, multiline=False
+                ),
+            )
         requirement = SDocNode(
             parent=parent_section,
             requirement_type=grammar_element.tag,
-            mid=requirement_mid,
             fields=fields,
             relations=[],
         )
         requirement.ng_level = level
-
+        for field_ in fields:
+            field_.parent = requirement
         if foreign_key_id_or_none is not None:
             spec_object_parents = reqif_bundle.get_spec_object_parents(
                 spec_object.identifier
             )
             parent_refs: List[Reference] = []
             for spec_object_parent in spec_object_parents:
+                spec_relation_type = (
+                    context.map_source_target_pairs_to_spec_relation_types[
+                        (spec_object.identifier, spec_object_parent)
+                    ]
+                )
+
+                relation_role = (
+                    spec_relation_type.long_name
+                    if spec_relation_type.long_name is not None
+                    else None
+                )
+                if relation_role == "Parent":
+                    relation_role = None
+
+                if (
+                    grammar_element
+                    not in context.unique_grammar_element_relations
+                ):
+                    context.unique_grammar_element_relations[
+                        grammar_element
+                    ] = OrderedSet()
+
+                if (
+                    "Parent",
+                    relation_role,
+                ) not in context.unique_grammar_element_relations[
+                    grammar_element
+                ]:
+                    context.unique_grammar_element_relations[
+                        grammar_element
+                    ].add(("Parent", relation_role))
+                    grammar_element.relations.append(
+                        GrammarElementRelationParent(
+                            parent=grammar_element,
+                            relation_type="Parent",
+                            relation_role=relation_role,
+                        )
+                    )
+
                 parent_spec_object_parent = (
                     reqif_bundle.lookup.get_spec_object_by_ref(
                         spec_object_parent
@@ -527,7 +597,7 @@ class P01_ReqIFToSDocConverter:
                         parent_spec_object_parent.attribute_map[
                             foreign_key_id_or_none
                         ].value,
-                        role=None,
+                        role=relation_role,
                     )
                 )
             if len(parent_refs) > 0:

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/reqif/p01_sdoc/sdoc_to_reqif_converter.py

@@ -3,7 +3,7 @@ import datetime
 import uuid
 from collections import defaultdict
 from enum import Enum
-from typing import Dict, List
+from typing import Dict, List, Optional, Tuple
 
 from reqif.models.reqif_core_content import ReqIFCoreContent
 from reqif.models.reqif_data_type import (
@@ -22,6 +22,7 @@ from reqif.models.reqif_spec_object_type import (
     SpecAttributeDefinition,
 )
 from reqif.models.reqif_spec_relation import ReqIFSpecRelation
+from reqif.models.reqif_spec_relation_type import ReqIFSpecRelationType
 from reqif.models.reqif_specification import ReqIFSpecification
 from reqif.models.reqif_specification_type import ReqIFSpecificationType
 from reqif.models.reqif_types import SpecObjectAttributeType
@@ -29,7 +30,6 @@ from reqif.object_lookup import ReqIFObjectLookup
 from reqif.reqif_bundle import ReqIFBundle
 
 from strictdoc.backend.reqif.sdoc_reqif_fields import (
-    SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON,
     SDOC_SPECIFICATION_TYPE_SINGLETON,
     SDOC_TO_REQIF_FIELD_MAP,
     ReqIFChapterField,
@@ -38,18 +38,22 @@ from strictdoc.backend.reqif.sdoc_reqif_fields import (
 from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.models.document_grammar import DocumentGrammar
 from strictdoc.backend.sdoc.models.node import SDocNode
-from strictdoc.backend.sdoc.models.reference import ParentReqReference
+from strictdoc.backend.sdoc.models.reference import (
+    ChildReqReference,
+    ParentReqReference,
+    Reference,
+)
 from strictdoc.backend.sdoc.models.section import SDocSection
 from strictdoc.backend.sdoc.models.type_system import (
     GrammarElementField,
     GrammarElementFieldMultipleChoice,
     GrammarElementFieldSingleChoice,
     GrammarElementFieldString,
-    ReferenceType,
 )
 from strictdoc.core.document_iterator import DocumentCachingIterator
 from strictdoc.core.document_tree import DocumentTree
 from strictdoc.helpers.cast import assert_cast
+from strictdoc.helpers.ordered_set import OrderedSet
 from strictdoc.helpers.string import escape
 
 
@@ -69,10 +73,15 @@ class P01_SDocToReqIFBuildContext:
         self.multiline_is_xhtml: bool = multiline_is_xhtml
         self.enable_mid: bool = enable_mid
         self.map_uid_to_spec_objects: Dict[str, ReqIFSpecObject] = {}
-        self.map_uid_to_parent_uids: Dict[str, List[str]] = {}
+        self.map_node_uids_to_their_relations: Dict[str, List[Reference]] = (
+            defaultdict(list)
+        )
         self.map_grammar_node_tags_to_spec_object_type: Dict[
             SDocDocument, Dict[str, ReqIFSpecObjectType]
         ] = defaultdict(dict)
+        self.map_spec_relation_tuple_to_spec_relation_type: Dict[
+            Tuple[str, Optional[str]], ReqIFSpecRelationType
+        ] = {}
 
 
 class P01_SDocToReqIFObjectConverter:
@@ -235,21 +244,22 @@ class P01_SDocToReqIFObjectConverter:
             current_hierarchy = root_hierarchy
 
             # FIXME: ReqIF must export complete documents including fragments.
-            for node in document_iterator.all_content(
+            for node_ in document_iterator.all_content(
                 print_fragments=False, print_fragments_from_files=False
             ):
-                if node.is_composite_requirement:
+                if node_.is_composite_requirement:
                     raise NotImplementedError(
                         "Exporting composite requirements is not "
                         "supported yet.",
-                        node,
+                        node_,
                     )
-                if node.is_section:
+                if node_.is_section:
+                    section: SDocSection = assert_cast(node_, SDocSection)
                     # fmt: off
                     spec_object = (
                         P01_SDocToReqIFObjectConverter
                         ._convert_section_to_spec_object(
-                            section=node,
+                            section=section,
                             context=context,
                         )
                     )
@@ -264,14 +274,14 @@ class P01_SDocToReqIFObjectConverter:
                         spec_object=spec_object.identifier,
                         children=[],
                         ref_then_children_order=True,
-                        level=node.ng_level,
+                        level=section.ng_level,
                     )
-                    if node.ng_level > current_hierarchy.level:
+                    if section.ng_level > current_hierarchy.level:
                         parents[hierarchy] = current_hierarchy
                         current_hierarchy.add_child(hierarchy)
-                    elif node.ng_level < current_hierarchy.level:
+                    elif section.ng_level < current_hierarchy.level:
                         for _ in range(
-                            0, (current_hierarchy.level - node.ng_level + 1)
+                            0, (current_hierarchy.level - section.ng_level + 1)
                         ):
                             current_hierarchy = parents[current_hierarchy]
                         current_hierarchy.add_child(hierarchy)
@@ -282,9 +292,10 @@ class P01_SDocToReqIFObjectConverter:
                         parents[hierarchy] = current_hierarchy_parent
                     current_hierarchy = hierarchy
 
-                elif node.is_requirement:
+                elif node_.is_requirement:
+                    requirement = assert_cast(node_, SDocNode)
                     spec_object = cls._convert_requirement_to_spec_object(
-                        requirement=node,
+                        requirement=requirement,
                         grammar=assert_cast(document.grammar, DocumentGrammar),
                         context=context,
                         data_types=data_types,
@@ -302,10 +313,10 @@ class P01_SDocToReqIFObjectConverter:
                         spec_object=spec_object.identifier,
                         children=None,
                         ref_then_children_order=True,
-                        level=node.ng_level,
+                        level=requirement.ng_level,
                     )
                     for _ in range(
-                        0, (current_hierarchy.level - node.ng_level + 1)
+                        0, (current_hierarchy.level - requirement.ng_level + 1)
                     ):
                         current_hierarchy = parents[current_hierarchy]
                     parents[hierarchy] = current_hierarchy
@@ -332,18 +343,31 @@ class P01_SDocToReqIFObjectConverter:
 
         for (
             requirement_id,
-            parent_uids,
-        ) in context.map_uid_to_parent_uids.items():
+            node_relations_,
+        ) in context.map_node_uids_to_their_relations.items():
             spec_object = context.map_uid_to_spec_objects[requirement_id]
-            for parent_uid in parent_uids:
-                parent_spec_object = context.map_uid_to_spec_objects[parent_uid]
+            for node_relation_ in node_relations_:
+                # For now, the File-relations are not supported.
+                if not isinstance(
+                    node_relation_, (ParentReqReference, ChildReqReference)
+                ):
+                    continue
+                related_node_uid = node_relation_.ref_uid
+                parent_spec_object = context.map_uid_to_spec_objects[
+                    related_node_uid
+                ]
+                spec_relation_type: ReqIFSpecRelationType = (
+                    context.map_spec_relation_tuple_to_spec_relation_type[
+                        (node_relation_.ref_type, node_relation_.role)
+                    ]
+                )
                 spec_relations.append(
                     ReqIFSpecRelation(
                         xml_node=None,
                         description=None,
                         identifier=generate_unique_identifier("SPEC-RELATION"),
                         last_change=None,
-                        relation_type_ref=SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON,
+                        relation_type_ref=spec_relation_type.identifier,
                         source=spec_object.identifier,
                         target=parent_spec_object.identifier,
                         values_attribute=None,
@@ -465,6 +489,9 @@ class P01_SDocToReqIFObjectConverter:
 
         attributes: List[SpecObjectAttribute] = []
         for field in requirement.fields_as_parsed:
+            # The MID field, if exists, is extracted separately as a ReqIF Identifier.
+            if field.field_name == "MID":
+                continue
             grammar_field = grammar_element.fields_map[field.field_name]
             if isinstance(grammar_field, GrammarElementFieldSingleChoice):
                 data_type_ref = data_types_lookup[field.field_name]
@@ -539,18 +566,10 @@ class P01_SDocToReqIFObjectConverter:
             attributes.append(attribute)
 
         if requirement.reserved_uid is not None:
-            parent_references: List[str] = []
-            for reference in requirement.relations:
-                if reference.ref_type != ReferenceType.PARENT:
-                    continue
-                parent_reference: ParentReqReference = assert_cast(
-                    reference, ParentReqReference
-                )
-                parent_references.append(parent_reference.ref_uid)
-
-            context.map_uid_to_parent_uids[requirement.reserved_uid] = (
-                parent_references
-            )
+            if len(requirement.relations) > 0:
+                context.map_node_uids_to_their_relations[
+                    requirement.reserved_uid
+                ] = requirement.relations
 
         spec_object_type: ReqIFSpecObjectType = (
             context.map_grammar_node_tags_to_spec_object_type[
@@ -665,7 +684,31 @@ class P01_SDocToReqIFObjectConverter:
         ] = section_spec_type
         spec_object_types.append(section_spec_type)
 
-        return spec_object_types
+        # Using dict as an ordered set.
+        spec_relation_tuples: OrderedSet = OrderedSet()
+        for element_ in grammar.elements:
+            for relation_ in element_.relations:
+                spec_relation_tuples.add(
+                    (relation_.relation_type, relation_.relation_role)
+                )
+
+        spec_relation_types: List = []
+        for spec_relation_tuple_ in spec_relation_tuples:
+            spec_relation_type_name = (
+                spec_relation_tuple_[1]
+                if spec_relation_tuple_[1] is not None
+                else spec_relation_tuple_[0]
+            )
+            spec_relation_type = ReqIFSpecRelationType(
+                identifier=generate_unique_identifier(spec_relation_type_name),
+                long_name=spec_relation_type_name,
+            )
+            spec_relation_types.append(spec_relation_type)
+            context.map_spec_relation_tuple_to_spec_relation_type[
+                spec_relation_tuple_
+            ] = spec_relation_type
+
+        return spec_object_types + spec_relation_types
 
     @classmethod
     def _create_section_spec_object_type(

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/reqif/sdoc_reqif_fields.py

@@ -62,7 +62,3 @@ DEFAULT_SDOC_GRAMMAR_FIELDS = [
 ]
 
 SDOC_SPECIFICATION_TYPE_SINGLETON = "SDOC_SPECIFICATION_TYPE_SINGLETON"
-
-SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON = (
-    "SDOC_SPEC_RELATION_PARENT_TYPE_SINGLETON"
-)

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/sdoc/error_handling.py

@@ -298,6 +298,25 @@ class StrictDocSemanticError(Exception):
             filename=path_to_sdoc_file,
         )
 
+    @staticmethod
+    def grammar_element_has_no_mid_field(
+        grammar_element: GrammarElement,
+        path_to_sdoc_file: str,
+    ):
+        return StrictDocSemanticError(
+            title=(
+                f"Grammar element '{grammar_element.tag}' is missing the MID field "
+                f"which contradicts to the DOCUMENT's ENABLE_MID setting."
+            ),
+            hint=(
+                "Either disable the ENABLE_MID option or ensure that every element has the MID field defined."
+            ),
+            example=None,
+            line=1,
+            col=1,
+            filename=path_to_sdoc_file,
+        )
+
     @staticmethod
     def view_references_nonexisting_grammar_element(
         document: SDocDocument,

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/sdoc/grammar/grammar.py

@@ -1,8 +1,9 @@
-REGEX_UID = r"([A-Za-z0-9]+[A-Za-z0-9_\-]*)"
+REGEX_UID = r"([\w]+[\w()\-. ]*)"
 
 NEGATIVE_MULTILINE_STRING_START = "(?!>>>\n)"
 NEGATIVE_MULTILINE_STRING_END = "(?!^<<<)"
 NEGATIVE_RELATIONS = "(?!^RELATIONS)"
+NEGATIVE_UID = "(?!^UID)"
 NEGATIVE_FREETEXT_END = "(?!^\\[\\/FREETEXT\\]\n)"
 NEGATIVE_INLINE_LINK_START = rf"(?!\[LINK: {REGEX_UID})"
 NEGATIVE_ANCHOR_START = rf"(?!^\[ANCHOR: {REGEX_UID})"
@@ -44,7 +45,7 @@ MultiLineString[noskipws]:
 ;
 
 FieldName[noskipws]:
-  /{NEGATIVE_RELATIONS}[A-Z]+[A-Z_]*/
+  /{NEGATIVE_UID}{NEGATIVE_RELATIONS}[A-Z]+[A-Z_]*/
 ;
 """
 
@@ -174,7 +175,6 @@ ReservedKeyword[noskipws]:
 
 SDocNode[noskipws]:
   '[' !'SECTION' !SDocCompositeNodeTagName requirement_type = RequirementType ']' '\n'
-  ('MID: ' mid = SingleLineString '\n')?
   fields *= SDocNodeField
   (
     'RELATIONS:' '\n'
@@ -188,6 +188,10 @@ SDocCompositeNodeTagName[noskipws]:
 
 SDocNodeField[noskipws]:
   (
+    field_name = 'MID' ': ' parts+=SingleLineString '\n'
+    |
+    field_name = 'UID' ': ' parts+=/{REGEX_UID}/ '\n'
+    |
     field_name = FieldName ':'
     (
         (' ' parts+=SingleLineTextPart '\n')
@@ -208,8 +212,6 @@ SDocNodeField[noskipws]:
 SDocCompositeNode[noskipws]:
   '[COMPOSITE_' requirement_type = RequirementType ']' '\n'
 
-  ('MID: ' mid = SingleLineString '\n')?
-
   fields *= SDocNodeField
   (
     'RELATIONS:' '\n'

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/sdoc/grammar_reader.py

@@ -49,7 +49,7 @@ class SDocGrammarReader:
 
         if not grammar.has_text_element():
             grammar.add_element_first(
-                DocumentGrammar.create_default_text_element()
+                DocumentGrammar.create_default_text_element(grammar)
             )
 
         # HACK:

{strictdoc-0.0.58 → strictdoc-0.0.59a1}/strictdoc/backend/sdoc/models/anchor.py

@@ -30,11 +30,14 @@ class Anchor:
     def document(self):
         if self.parent.parent.__class__.__name__ == "SDocDocument":
             return self.parent.parent
-        return self.parent.parent.document
+        return self.parent_node().document
 
     @property
     def parent_or_including_document(self):
-        return self.parent.parent_or_including_document
+        return self.parent_node().parent_or_including_document
+
+    def get_including_document(self):
+        return self.parent_node().get_including_document()
 
     def parent_node(self) -> Any:
         # Anchor -> FreeText -> Section|Document

strictdoc-0.0.59a1/strictdoc/backend/sdoc/models/any_node.py

@@ -0,0 +1,12 @@
+from typing import Union
+
+from strictdoc.backend.sdoc.models.document import SDocDocument
+from strictdoc.backend.sdoc.models.node import SDocCompositeNode, SDocNode
+from strictdoc.backend.sdoc.models.section import SDocSection
+
+SDocAnyNode = Union[
+    SDocCompositeNode,
+    SDocSection,
+    SDocNode,
+    SDocDocument,
+]