strictdoc 0.0.56a4__tar.gz → 0.0.57a1__tar.gz

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.56a4
+Version: 0.0.57a1
 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.56a4 → strictdoc-0.0.57a1}/strictdoc/__init__.py

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

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/excel/export/excel_generator.py

@@ -132,12 +132,15 @@ class ExcelGenerator:
                         elif field_uc in ("COMMENT", "COMMENTS"):
                             # Using a transition marker to separate multiple
                             # comments
-                            if node.comments:
+                            comment_fields = node.get_comment_fields()
+                            if len(comment_fields) > 0:
                                 comment_row_value: str = ""
-                                for comment in node.comments:
+                                for comment_field_ in comment_fields:
                                     if len(comment_row_value) > 0:
                                         comment_row_value += "\n----------\n"
-                                    comment_row_value += comment
+                                    comment_row_value += (
+                                        comment_field_.get_text_value()
+                                    )
                                 worksheet.write(row, idx, comment_row_value)
                                 if (
                                     comment_row_value
@@ -172,7 +175,7 @@ class ExcelGenerator:
                                     columns[field][MAX_WIDTH_KEY] = value_len
                         elif field_uc in node.ordered_fields_lookup.keys():
                             req_field = node.ordered_fields_lookup[field_uc][0]
-                            value: str = req_field.get_value()
+                            value: str = req_field.get_text_value()
                             worksheet.write(row, idx, value)
                             value_len = len(value)
                             if value_len > columns[field][MAX_WIDTH_KEY]:

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/excel/import_/excel_to_sdoc_converter.py

@@ -130,8 +130,11 @@ class ExcelToSDocConverter:
             section_contents=[],
         )
 
+        # FIXME: This is becoming very limiting. It must work against a complete grammar.
         fields = list(
-            DocumentGrammar.create_default(document).elements[0].fields
+            DocumentGrammar.create_default(document)
+            .elements_by_type["REQUIREMENT"]
+            .fields
         )
 
         for _, name in extra_header_pairs:

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/reqif/p01_sdoc/sdoc_to_reqif_converter.py

@@ -551,7 +551,7 @@ class P01_SDocToReqIFObjectConverter:
                 for data_type in data_types:
                     if data_type_ref == data_type.identifier:
                         for data_type_value in data_type.values:
-                            if data_type_value.key == field.get_value():
+                            if data_type_value.key == field.get_text_value():
                                 enum_ref_value = data_type_value.identifier
                                 break
 
@@ -564,7 +564,7 @@ class P01_SDocToReqIFObjectConverter:
                     value=[enum_ref_value],
                 )
             elif isinstance(grammar_field, GrammarElementFieldMultipleChoice):
-                field_values: List[str] = field.get_value().split(",")
+                field_values: List[str] = field.get_text_value().split(",")
                 field_values = list(map(lambda v: v.strip(), field_values))
 
                 data_type_ref = data_types_lookup[field.field_name]
@@ -590,7 +590,7 @@ class P01_SDocToReqIFObjectConverter:
             elif isinstance(grammar_field, GrammarElementFieldString):
                 is_multiline_field = field.is_multiline()
 
-                field_value: str = field.get_value().rstrip()
+                field_value: str = field.get_text_value().rstrip()
 
                 attribute_type: str
                 if context.multiline_is_xhtml:
@@ -743,7 +743,9 @@ class P01_SDocToReqIFObjectConverter:
         ] = section_spec_type
         spec_object_types.append(section_spec_type)
         free_text_spec_type = (
-            P01_SDocToReqIFObjectConverter._create_free_text_spec_object_type()
+            P01_SDocToReqIFObjectConverter._create_free_text_spec_object_type(
+                context
+            )
         )
         context.map_grammar_node_tags_to_spec_object_type[grammar.parent][
             "FREETEXT"
@@ -776,12 +778,15 @@ class P01_SDocToReqIFObjectConverter:
     @classmethod
     def _create_free_text_spec_object_type(
         cls,
+        context: P01_SDocToReqIFBuildContext,
     ):
         attribute_definitions = []
         chapter_name_attribute = SpecAttributeDefinition.create(
-            attribute_type=SpecObjectAttributeType.STRING,
+            attribute_type=SpecObjectAttributeType.XHTML
+            if context.multiline_is_xhtml
+            else SpecObjectAttributeType.STRING,
             identifier=ReqIFChapterField.TEXT,
-            datatype_definition=(StrictDocReqIFTypes.MULTI_LINE_STRING.value),
+            datatype_definition=StrictDocReqIFTypes.MULTI_LINE_STRING.value,
             long_name=ReqIFChapterField.TEXT,
         )
         attribute_definitions.append(chapter_name_attribute)

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/reqif/p02_simple/sdoc_to_reqif_converter.py

@@ -556,7 +556,7 @@ class P02_SDocToReqIFObjectConverter:
                 for data_type in data_types:
                     if data_type_ref == data_type.identifier:
                         for data_type_value in data_type.values:
-                            if data_type_value.key == field.get_value():
+                            if data_type_value.key == field.get_text_value():
                                 enum_ref_value = data_type_value.identifier
                                 break
 
@@ -569,7 +569,7 @@ class P02_SDocToReqIFObjectConverter:
                     value=[enum_ref_value],
                 )
             elif isinstance(grammar_field, GrammarElementFieldMultipleChoice):
-                field_values: List[str] = field.get_value().split(",")
+                field_values: List[str] = field.get_text_value().split(",")
                 field_values = list(map(lambda v: v.strip(), field_values))
 
                 data_type_ref = data_types_lookup[field.field_name]
@@ -595,7 +595,7 @@ class P02_SDocToReqIFObjectConverter:
             elif isinstance(grammar_field, GrammarElementFieldString):
                 is_multiline_field = field.is_multiline()
 
-                field_value: str = field.get_value()
+                field_value: str = field.get_text_value()
 
                 attribute_type: str
                 if context.multiline_is_xhtml:

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/error_handling.py

@@ -150,7 +150,7 @@ class StrictDocSemanticError(Exception):
         return StrictDocSemanticError(
             title=(
                 f"Requirement field has an invalid SingleChoice value: "
-                f"{requirement_field.get_value()}."
+                f"{requirement_field.get_text_value()}."
             ),
             hint=(
                 f"Problematic field: {requirement_field.field_name}. "
@@ -176,7 +176,7 @@ class StrictDocSemanticError(Exception):
         return StrictDocSemanticError(
             title=(
                 f"Requirement field has an invalid MultipleChoice value: "
-                f"{requirement_field.get_value()}."
+                f"{requirement_field.get_text_value()}."
             ),
             hint=(
                 f"Problematic field: {requirement_field.field_name}. "
@@ -201,7 +201,7 @@ class StrictDocSemanticError(Exception):
         return StrictDocSemanticError(
             title=(
                 f"Requirement field of type MultipleChoice is invalid: "
-                f"{requirement_field.get_value()}."
+                f"{requirement_field.get_text_value()}."
             ),
             hint="MultipleChoice field requires ', '-separated values.",
             example=None,
@@ -219,7 +219,7 @@ class StrictDocSemanticError(Exception):
         return StrictDocSemanticError(
             title=(
                 f"Requirement field of type Tag is invalid: "
-                f"{requirement_field.get_value()}."
+                f"{requirement_field.get_text_value()}."
             ),
             hint="Tag field requires ', '-separated values.",
             example=None,

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/models/anchor.py

@@ -23,6 +23,9 @@ class Anchor:
         self.mid: MID = MID.create()
         self.reserved_mid: MID = self.mid
 
+    def get_display_title(self) -> str:
+        return self.title
+
     @property
     def document(self):
         if self.parent.parent.__class__.__name__ == "SDocDocument":

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/models/document.py

@@ -143,7 +143,7 @@ class SDocDocument:
             task_list.extend(section_or_requirement.section_contents)
         return False
 
-    def get_title(self) -> str:
+    def get_display_title(self) -> str:
         return self.title
 
     @property

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/models/document_grammar.py

@@ -1,4 +1,4 @@
-# mypy: disable-error-code="no-redef,no-untyped-call,no-untyped-def,union-attr,type-arg"
+# mypy: disable-error-code="no-untyped-call,no-untyped-def,union-attr,type-arg"
 from collections import OrderedDict
 from typing import Dict, List, Optional, Set, Tuple, Union
 
@@ -69,11 +69,7 @@ class GrammarElement:
                 GrammarElementRelationChild,
                 GrammarElementRelationFile,
             ]
-        ] = (
-            relations
-            if relations is not None and len(relations) > 0
-            else create_default_relations(self)
-        )
+        ] = relations if relations is not None and len(relations) > 0 else []
         fields_map: OrderedDict = OrderedDict()
 
         statement_field: Optional[Tuple[str, int]] = None
@@ -128,6 +124,11 @@ class GrammarElement:
             relations=[],
         )
 
+    def get_multiline_field_index(self) -> int:
+        multiline_field_index = self.content_field[1]
+        assert multiline_field_index != -1
+        return multiline_field_index
+
     def get_relation_types(self) -> List[str]:
         return list(
             map(lambda relation_: relation_.relation_type, self.relations)
@@ -202,7 +203,6 @@ class DocumentGrammar:
 
     @staticmethod
     def create_default(parent) -> "DocumentGrammar":
-        # @sdoc[SDOC-SRS-132]
         fields: List[
             Union[
                 GrammarElementFieldString,
@@ -210,6 +210,25 @@ class DocumentGrammar:
                 GrammarElementFieldMultipleChoice,
             ]
         ] = [
+            GrammarElementFieldString(
+                parent=None,
+                title=RequirementFieldName.UID,
+                human_title=None,
+                required="False",
+            ),
+            GrammarElementFieldString(
+                parent=None,
+                title=RequirementFieldName.STATEMENT,
+                human_title=None,
+                required="True",
+            ),
+        ]
+        text_element = GrammarElement(
+            parent=None, tag="TEXT", fields=fields, relations=[]
+        )
+
+        # @sdoc[SDOC-SRS-132]
+        fields = [
             GrammarElementFieldString(
                 parent=None,
                 title=RequirementFieldName.UID,
@@ -268,11 +287,13 @@ class DocumentGrammar:
             requirement_element
         )
 
-        elements: List[GrammarElement] = [requirement_element]
+        elements: List[GrammarElement] = [text_element, requirement_element]
         grammar = DocumentGrammar(
             parent=parent, elements=elements, import_from_file=None
         )
         grammar.is_default = True
+        text_element.parent = grammar
+        requirement_element.parent = grammar
 
         return grammar
 
@@ -315,8 +336,8 @@ class DocumentGrammar:
             elements_by_type[element.tag] = element
 
         self.elements = elements
-        self.registered_elements: Set[str] = registered_elements
-        self.elements_by_type: Dict[str, GrammarElement] = elements_by_type
+        self.registered_elements = registered_elements
+        self.elements_by_type = elements_by_type
 
 
 class DocumentGrammarWrapper:

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/models/node.py

@@ -1,13 +1,16 @@
 # mypy: disable-error-code="union-attr"
+import html
 from collections import OrderedDict
 from typing import Any, Generator, List, Optional, Tuple, Union
 
 from strictdoc.backend.sdoc.document_reference import DocumentReference
+from strictdoc.backend.sdoc.models.anchor import Anchor
 from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.models.document_grammar import (
     DocumentGrammar,
     GrammarElement,
 )
+from strictdoc.backend.sdoc.models.inline_link import InlineLink
 from strictdoc.backend.sdoc.models.object import SDocObject
 from strictdoc.backend.sdoc.models.reference import (
     ChildReqReference,
@@ -46,8 +49,6 @@ class SDocNodeField:
         self.parts: List[Any] = parts
         self.multiline: bool = multiline__ is not None and len(multiline__) > 0
 
-        self.resolved_field_value: str = "".join(parts)
-
     @staticmethod
     def create_from_string(
         parent: Optional["SDocNode"],
@@ -70,8 +71,30 @@ class SDocNodeField:
     def is_multiline(self) -> bool:
         return self.multiline
 
-    def get_value(self) -> str:
-        return self.resolved_field_value
+    def get_text_value(self) -> str:
+        text = ""
+        for part in self.parts:
+            if isinstance(part, str):
+                text += part
+            elif isinstance(part, InlineLink):
+                text += "[LINK: "
+                text += part.link
+                text += "]"
+            elif isinstance(part, Anchor):
+                text += "[ANCHOR: "
+                text += part.value
+                if part.has_title:
+                    text += ", "
+                    text += part.title
+                text += "]"
+                text += "\n"
+                text += "\n"
+            else:
+                raise NotImplementedError(part)
+        return text
+
+    def get_text_value_escaped(self) -> str:
+        return html.escape(self.get_text_value())
 
 
 @auto_described
@@ -140,7 +163,7 @@ class SDocNode(SDocObject):
         if RequirementFieldName.LEVEL in ordered_fields_lookup:
             level = ordered_fields_lookup[RequirementFieldName.LEVEL][
                 0
-            ].get_value()
+            ].get_text_value()
             self.ng_resolved_custom_level = level
             self.custom_level = level
 
@@ -154,8 +177,12 @@ class SDocNode(SDocObject):
     def get_node_type_string(self) -> Optional[str]:
         return self.requirement_type
 
-    def get_title(self) -> Optional[str]:
-        return self.reserved_title
+    def get_display_title(self) -> str:
+        if self.reserved_title is not None:
+            return self.reserved_title
+        if self.reserved_uid is not None:
+            return self.reserved_uid
+        return f"{self.requirement_type} with no title/UID"
 
     @property
     def is_root_included_document(self) -> bool:
@@ -189,7 +216,7 @@ class SDocNode(SDocObject):
         assert (
             not field.is_multiline()
         ), f"Field {RequirementFieldName.TAGS} must be a single-line field."
-        tags = field.get_value().split(", ")
+        tags = field.get_text_value().split(", ")
         return tags
 
     @property
@@ -198,6 +225,12 @@ class SDocNode(SDocObject):
             RequirementFieldName.TITLE, singleline_only=True
         )
 
+    def has_reserved_statement(self) -> bool:
+        element: GrammarElement = self.document.grammar.elements_by_type[
+            self.requirement_type
+        ]
+        return element.content_field[0] in self.ordered_fields_lookup
+
     @property
     def reserved_statement(self) -> Optional[str]:
         element: GrammarElement = self.document.grammar.elements_by_type[
@@ -213,28 +246,31 @@ class SDocNode(SDocObject):
             RequirementFieldName.RATIONALE, singleline_only=False
         )
 
-    @property
-    def comments(self) -> List[str]:
-        if RequirementFieldName.COMMENT not in self.ordered_fields_lookup:
-            return []
-        comments = []
-        for field in self.ordered_fields_lookup[RequirementFieldName.COMMENT]:
-            comments.append(field.get_value())
-        return comments
-
     # Other properties
+    # FIXME: Remove @property.
     @property
     def is_requirement(self) -> bool:
         return True
 
+    def is_text_node(self) -> bool:
+        return self.requirement_type == "TEXT"
+
+    # FIXME: Remove @property.
     @property
     def is_section(self) -> bool:
         return False
 
+    # FIXME: Remove @property.
+    @property
+    def is_document(self) -> bool:
+        return False
+
+    # FIXME: Remove @property.
     @property
     def is_composite_requirement(self) -> bool:
         return False
 
+    # FIXME: Remove @property, use get_document().
     @property
     def document(self) -> SDocDocument:
         document: Optional[SDocDocument] = (
@@ -280,6 +316,20 @@ class SDocNode(SDocObject):
         ]
         return element.content_field[0]
 
+    def get_content_field(self) -> SDocNodeField:
+        element: GrammarElement = self.document.grammar.elements_by_type[
+            self.requirement_type
+        ]
+        return self.ordered_fields_lookup[element.content_field[0]][0]
+
+    def get_field_by_name(self, field_name: str) -> SDocNodeField:
+        return self.ordered_fields_lookup[field_name][0]
+
+    def get_comment_fields(self) -> List[SDocNodeField]:
+        if RequirementFieldName.COMMENT not in self.ordered_fields_lookup:
+            return []
+        return self.ordered_fields_lookup[RequirementFieldName.COMMENT]
+
     def has_requirement_references(self, ref_type: str) -> bool:
         if len(self.relations) == 0:
             return False
@@ -368,12 +418,12 @@ class SDocNode(SDocObject):
         self,
     ) -> Generator[Tuple[SDocNodeField, str, str], None, None]:
         for field in self.enumerate_fields():
-            meta_field_value = field.get_value()
+            meta_field_value = field.get_text_value()
             yield field, field.field_name, meta_field_value
 
     def enumerate_meta_fields(
         self, skip_single_lines: bool = False, skip_multi_lines: bool = False
-    ) -> Generator[Tuple[str, str], None, None]:
+    ) -> Generator[Tuple[str, SDocNodeField], None, None]:
         element: GrammarElement = self.document.grammar.elements_by_type[
             self.requirement_type
         ]
@@ -382,7 +432,6 @@ class SDocNode(SDocObject):
         for field in self.enumerate_fields():
             if field.field_name in RESERVED_NON_META_FIELDS:
                 continue
-            meta_field_value = field.get_value()
             field_index = grammar_field_titles.index(field.field_name)
 
             # A field is considered singleline if it goes before the STATEMENT
@@ -398,14 +447,14 @@ class SDocNode(SDocObject):
                 continue
 
             field_human_title = element.fields_map[field.field_name]
-            yield field_human_title.get_field_human_name(), meta_field_value
+            yield field_human_title.get_field_human_name(), field
 
     def get_meta_field_value_by_title(self, field_title: str) -> Optional[str]:
         assert isinstance(field_title, str)
         if field_title not in self.ordered_fields_lookup:
             return None
         field: SDocNodeField = self.ordered_fields_lookup[field_title][0]
-        return field.get_value()
+        return field.get_text_value()
 
     def get_field_human_title(self, field_name: str) -> str:
         element: GrammarElement = self.document.grammar.elements_by_type[
@@ -449,7 +498,7 @@ class SDocNode(SDocObject):
                 f"Field {field_name} must be a single-line field."
             )
 
-        return field.get_value()
+        return field.get_text_value()
 
     # Below all mutating methods.
 

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/models/section.py

@@ -21,9 +21,9 @@ class SDocSection(SDocObject):  # pylint: disable=too-many-instance-attributes
         self,
         parent,
         mid: Optional[str],
-        uid,
+        uid: Optional[str],
         custom_level: Optional[str],
-        title,
+        title: str,
         requirement_prefix: Optional[str],
         free_texts: List[FreeText],
         section_contents: List[SDocObject],
@@ -37,7 +37,7 @@ class SDocSection(SDocObject):  # pylint: disable=too-many-instance-attributes
         self.uid: Optional[str] = meaningful_uid
         self.reserved_uid: Optional[str] = meaningful_uid
 
-        self.title = title
+        self.title: str = title
         self.reserved_title = title
         self.requirement_prefix: Optional[str] = requirement_prefix
 
@@ -71,7 +71,7 @@ class SDocSection(SDocObject):  # pylint: disable=too-many-instance-attributes
     def is_root_included_document(self):
         return False
 
-    def get_title(self):
+    def get_display_title(self) -> str:
         return self.title
 
     @property

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/validations/sdoc_validator.py

@@ -260,8 +260,11 @@ class SDocValidator:
                     path_to_sdoc_file=path_to_sdoc_file,
                 )
             return False
+
+        requirement_field_text_value = requirement_field.get_text_value()
+
         if isinstance(grammar_field, GrammarElementFieldSingleChoice):
-            if requirement_field.get_value() not in grammar_field.options:
+            if requirement_field_text_value not in grammar_field.options:
                 raise StrictDocSemanticError.invalid_choice_field(
                     node=requirement,
                     document_grammar=document_grammar,
@@ -270,17 +273,15 @@ class SDocValidator:
                 )
 
         elif isinstance(grammar_field, GrammarElementFieldMultipleChoice):
-            requirement_field_value = requirement_field.get_value()
-
-            if not multi_choice_regex_match(requirement_field_value):
+            if not multi_choice_regex_match(requirement_field_text_value):
                 raise StrictDocSemanticError.not_comma_separated_choices(
                     node=requirement,
                     requirement_field=requirement_field,
                     path_to_sdoc_file=path_to_sdoc_file,
                 )
 
-            requirement_field_value_components = requirement_field_value.split(
-                ", "
+            requirement_field_value_components = (
+                requirement_field_text_value.split(", ")
             )
             for component in requirement_field_value_components:
                 if component not in grammar_field.options:
@@ -292,9 +293,7 @@ class SDocValidator:
                     )
 
         elif isinstance(grammar_field, GrammarElementFieldTag):
-            requirement_field_value = requirement_field.get_value()
-
-            if not multi_choice_regex_match(requirement_field_value):
+            if not multi_choice_regex_match(requirement_field_text_value):
                 raise StrictDocSemanticError.not_comma_separated_tag_field(
                     node=requirement,
                     requirement_field=requirement_field,

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/backend/sdoc/writer.py

@@ -217,18 +217,15 @@ class SDWriter:
                         )
 
                     relations: List = element.relations
-                    assert len(relations) > 0, relations
+                    if len(relations) > 0:
+                        output += "  RELATIONS:\n"
 
-                    output += "  RELATIONS:\n"
-
-                    for element_relation in relations:
-                        output += (
-                            f"  - TYPE: {element_relation.relation_type}\n"
-                        )
-                        if element_relation.relation_role is not None:
+                        for element_relation in relations:
                             output += (
-                                f"    ROLE: {element_relation.relation_role}\n"
+                                f"  - TYPE: {element_relation.relation_type}\n"
                             )
+                            if element_relation.relation_role is not None:
+                                output += f"    ROLE: {element_relation.relation_role}\n"
 
         for free_text in document.free_texts:
             output += "\n"
@@ -388,7 +385,7 @@ class SDWriter:
                 continue
             fields = section_content.ordered_fields_lookup[field_name]
             for field in fields:
-                field_value = field.get_value()
+                field_value = field.get_text_value()
                 if field.is_multiline():
                     output += f"{field_name}: >>>"
                     output += "\n"

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/core/graph_database.py

@@ -61,6 +61,8 @@ class GraphDatabase:
         )
 
     def create_link(self, *, link_type: Hashable, lhs_node: Any, rhs_node: Any):
+        assert lhs_node is not None, lhs_node
+        assert rhs_node is not None, rhs_node
         self._id_to_bucket[link_type].create_link(
             lhs_node=lhs_node, rhs_node=rhs_node
         )
@@ -68,6 +70,8 @@ class GraphDatabase:
     def create_link_weak(
         self, *, link_type: Hashable, lhs_node: Any, rhs_node: Any
     ):
+        assert lhs_node is not None, lhs_node
+        assert rhs_node is not None, rhs_node
         self._id_to_bucket[link_type].create_link_weak(
             lhs_node=lhs_node, rhs_node=rhs_node
         )

{strictdoc-0.0.56a4 → strictdoc-0.0.57a1}/strictdoc/core/query_engine/query_object.py

@@ -253,7 +253,7 @@ class QueryObject:
             requirement = assert_cast(node, SDocNode)
             requirement_field_: SDocNodeField
             for requirement_field_ in requirement.enumerate_fields():
-                if expression.string in requirement_field_.get_value():
+                if expression.string in requirement_field_.get_text_value():
                     return True
             return False
         if isinstance(node, SDocSection):