strictdoc 0.0.49a2__tar.gz → 0.0.49a4__tar.gz

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.49a2
+Version: 0.0.49a4
 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.49a2 → strictdoc-0.0.49a4}/mypy.ini

@@ -22,8 +22,12 @@ ignore_missing_imports = True
 ignore_missing_imports = True
 
 # We ignore build folder but mypy still follows into the Python packages,
-# in this case starlette. This StackOverflow answers suggests a solution.
+# in this case pydantic, starlette, selenium.
+# This StackOverflow answers suggests a solution:
 # https://stackoverflow.com/a/70367929/598057
+[mypy-pydantic.*]
+follow_imports = skip
+
 [mypy-starlette.*]
 follow_imports = skip
 

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/requirements.check.txt

@@ -20,7 +20,7 @@ pytidylib>=0.3.2
 openpyxl>=3.0.5
 
 # End2end tests
-seleniumbase; python_version<="3.7"
+seleniumbase
 
 # psutil is needed to reap Uvicorn's zombie processes when running end2end
 # tests. One day someone finds a better solution.

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/__init__.py

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

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/excel/export/excel_generator.py

@@ -69,7 +69,7 @@ class ExcelGenerator:
             workbook.set_properties(
                 {
                     "title": project_config.project_title,
-                    "comments": "Created with StrictDoc",
+                    "comments": "Created with StrictDoc.",
                 }
             )
 
@@ -108,16 +108,19 @@ class ExcelGenerator:
                                     columns[field][MAX_WIDTH_KEY] = len(
                                         ref.ref_uid
                                     )
-                                worksheet.write_url(
-                                    row,
-                                    idx,
-                                    (
-                                        "internal:"
-                                        f"'{EXCEL_SHEET_NAME}'"
-                                        f"!A{req_uid_rows[ref.ref_uid]}"
-                                    ),
-                                    string=ref.ref_uid,
-                                )
+                                if ref.ref_uid in req_uid_rows:
+                                    worksheet.write_url(
+                                        row,
+                                        idx,
+                                        (
+                                            "internal:"
+                                            f"'{EXCEL_SHEET_NAME}'"
+                                            f"!A{req_uid_rows[ref.ref_uid]}"
+                                        ),
+                                        string=ref.ref_uid,
+                                    )
+                                else:
+                                    worksheet.write(row, idx, ref.ref_uid)
                         elif field_uc in ("COMMENT", "COMMENTS"):
                             # Using a transition marker to separate multiple
                             # comments

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/error_handling.py

@@ -5,6 +5,7 @@ from strictdoc.backend.sdoc.models.document_grammar import (
     GrammarElement,
     GrammarElementField,
 )
+from strictdoc.backend.sdoc.models.document_view import ViewElement
 from strictdoc.backend.sdoc.models.reference import Reference
 from strictdoc.backend.sdoc.models.requirement import (
     Requirement,
@@ -291,6 +292,71 @@ class StrictDocSemanticError(Exception):
             filename=filename,
         )
 
+    @staticmethod
+    def view_references_nonexisting_grammar_element(
+        view_element: ViewElement,
+        object_type: str,
+        line=None,
+        col=None,
+        filename=None,
+    ):
+        return StrictDocSemanticError(
+            title=(
+                f"View element '{view_element.view_id}' references a non-existing"
+                f" grammar element '{object_type}'."
+            ),
+            hint=(
+                "Make sure that each View element references an existing "
+                "object in the grammar or the default REQUIREMENT object."
+            ),
+            example=None,
+            line=line,
+            col=col,
+            filename=filename,
+        )
+
+    @staticmethod
+    def view_references_nonexisting_field(
+        view_element: ViewElement,
+        object_type: str,
+        field_name: str,
+        line=None,
+        col=None,
+        filename=None,
+    ):
+        return StrictDocSemanticError(
+            title=(
+                f"View element '{view_element.view_id}' references a non-existing"
+                f" field '{field_name}' for grammar element '{object_type}'."
+            ),
+            hint=(
+                "Make sure that each View element references an existing "
+                "field in the grammar for the given grammar element."
+            ),
+            example=None,
+            line=line,
+            col=col,
+            filename=filename,
+        )
+
+    @staticmethod
+    def default_view_doesnt_exist(
+        default_view: str, line=None, col=None, filename=None
+    ):
+        return StrictDocSemanticError(
+            title=(
+                f"Default view '{default_view}' does not exist in the document."
+            ),
+            hint=(
+                "Make sure that the specified default view is created in the "
+                "VIEWS configuration."
+            ),
+            example=None,
+            line=line,
+            col=col,
+            filename=filename,
+        )
+
     def to_print_message(self):
         message = ""
         message += f"error: could not parse file: {self.file_path}.\n"

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/models/constants.py

@@ -8,6 +8,10 @@ from strictdoc.backend.sdoc.models.document_grammar import (
     DocumentGrammar,
     GrammarElement,
 )
+from strictdoc.backend.sdoc.models.document_view import (
+    DocumentView,
+    ViewElement,
+)
 from strictdoc.backend.sdoc.models.fragment import Fragment
 from strictdoc.backend.sdoc.models.fragment_from_file import FragmentFromFile
 from strictdoc.backend.sdoc.models.inline_link import InlineLink
@@ -37,6 +41,9 @@ from strictdoc.backend.sdoc.models.type_system import (
     GrammarElementRelationChild,
     GrammarElementRelationFile,
     GrammarElementRelationParent,
+    ViewElementField,
+    ViewElementHiddenTag,
+    ViewElementTags,
 )
 
 SECTION_MODELS = [
@@ -62,6 +69,7 @@ DOCUMENT_MODELS = [
     DocumentConfig,
     Document,
     DocumentGrammar,
+    DocumentView,
     DocumentBibliography,
     GrammarElement,
     GrammarElementFieldString,
@@ -73,6 +81,10 @@ DOCUMENT_MODELS = [
     GrammarElementRelationParent,
     GrammarElementRelationChild,
     GrammarElementRelationFile,
+    ViewElement,
+    ViewElementField,
+    ViewElementTags,
+    ViewElementHiddenTag,
 ]
 DOCUMENT_MODELS.extend(SECTION_MODELS)
 

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/models/document.py

@@ -34,7 +34,9 @@ class Document:  # pylint: disable=too-many-instance-attributes
             if config is not None
             else DocumentConfig.default_config(self)
         )
-        self.view: Optional[DocumentView] = view
+        self.view: DocumentView = (
+            view if view is not None else DocumentView.create_default(self)
+        )
         self.grammar: Optional[DocumentGrammar] = grammar
         self.bibliography: Optional[DocumentBibliography] = bibliography
         self.free_texts: List[FreeText] = free_texts

strictdoc-0.0.49a4/strictdoc/backend/sdoc/models/document_view.py

@@ -0,0 +1,79 @@
+from typing import List, Optional
+
+from strictdoc.backend.sdoc.models.type_system import (
+    ViewElementField,
+    ViewElementHiddenTag,
+    ViewElementTags,
+)
+from strictdoc.helpers.auto_described import auto_described
+
+
+@auto_described()
+class ViewElement:
+    def __init__(
+        self,
+        parent,
+        view_id: str,
+        tags: List[ViewElementTags],
+        hidden_tags: Optional[List[ViewElementHiddenTag]],
+        name: Optional[str],
+    ):
+        self.parent = parent
+        self.view_id: str = view_id
+        self.tags: List[ViewElementTags] = tags
+        self.hidden_tags: Optional[List[ViewElementHiddenTag]] = hidden_tags
+        self.name: Optional[str] = name
+
+    def includes_field(self, requirement_type: str, field_name: str) -> bool:
+        for tag_ in self.tags:
+            if tag_.object_type == requirement_type:
+                field_: ViewElementField
+                for field_ in tag_.visible_fields:
+                    if field_.name == field_name:
+                        return True
+                break
+        return False
+
+
+@auto_described()
+class DefaultViewElement(ViewElement):
+    """
+    FIXME: It is not great to provide a default implementation this way but it
+           works fine for now.
+    """
+
+    def includes_field(self, requirement_type: str, field_name: str) -> bool:  # noqa: ARG002
+        return True
+
+
+@auto_described()
+class DocumentView:
+    def __init__(self, parent, views: List[ViewElement]):
+        self.parent = parent
+        self.views: List[ViewElement] = views
+
+    @staticmethod
+    def create_default(parent) -> "DocumentView":
+        return DocumentView(
+            parent,
+            [
+                DefaultViewElement(
+                    parent=parent,
+                    view_id="NOT_RELEVANT",
+                    tags=[],
+                    hidden_tags=[],
+                    name=None,
+                )
+            ],
+        )
+
+    def get_default_view(self) -> ViewElement:
+        return self.views[0]
+
+    def get_current_view(self, view_id: Optional[str]) -> ViewElement:
+        if view_id is None:
+            return self.get_default_view()
+        for view_element_ in self.views:
+            if view_element_.view_id == view_id:
+                return view_element_
+        raise NotImplementedError

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/models/requirement.py

@@ -549,6 +549,9 @@ class Requirement(Node):  # pylint: disable=too-many-instance-attributes, too-ma
             self.requirement_type
         ]
         grammar_field_titles = list(map(lambda f: f.title, element.fields))
+        # FIXME: This will go away very soon when the RELATIONS become a
+        #        separate field in SDoc REQUIREMENT's grammar.
+        grammar_field_titles.append("REFS")
         field_index = grammar_field_titles.index(field_name)
         title_field_index = grammar_field_titles.index(
             RequirementFieldName.TITLE

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/models/type_system.py

@@ -372,7 +372,8 @@ class GrammarElementFieldReference(GrammarElementField):
 
 @auto_described
 class ViewElementField:
-    def __init__(self, name: str, placement: Optional[str]):
+    def __init__(self, parent, name: str, placement: Optional[str]):
+        self.parent = parent
         self.name: str = name
         self.placement: Optional[str] = placement
 
@@ -380,13 +381,15 @@ class ViewElementField:
 @auto_described
 class ViewElementTags:
     def __init__(
-        self, object_type: str, visibile_fields: List[ViewElementField]
+        self, parent, object_type: str, visible_fields: List[ViewElementField]
     ):
+        self.parent = parent
         self.object_type: str = object_type
-        self.visible_fields: List[ViewElementField] = visibile_fields
+        self.visible_fields: List[ViewElementField] = visible_fields
 
 
 @auto_described
 class ViewElementHiddenTag:
-    def __init__(self, hidden_tag: str):
+    def __init__(self, parent, hidden_tag: str):
+        self.parent = parent
         self.hidden_tag: str = hidden_tag

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/processor.py

@@ -7,6 +7,7 @@ from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
 from strictdoc.backend.sdoc.models.document import Document
 from strictdoc.backend.sdoc.models.document_config import DocumentConfig
 from strictdoc.backend.sdoc.models.document_grammar import DocumentGrammar
+from strictdoc.backend.sdoc.models.document_view import DocumentView
 from strictdoc.backend.sdoc.models.fragment import Fragment
 from strictdoc.backend.sdoc.models.fragment_from_file import FragmentFromFile
 from strictdoc.backend.sdoc.models.requirement import (
@@ -25,6 +26,7 @@ class ParseContext:
         self.document_grammar: DocumentGrammar = DocumentGrammar.create_default(
             None
         )
+        self.document_view: Optional[DocumentView] = None
         self.current_include_parent = None
         self.uses_old_refs_field: bool = False
         self.at_least_one_relations_field: bool = False
@@ -43,6 +45,7 @@ class SDocParsingProcessor:
             "Document": self.process_document,
             "DocumentConfig": self.process_document_config,
             "DocumentGrammar": self.process_document_grammar,
+            "DocumentView": self.process_document_view,
             "Section": self.process_section,
             "FragmentFromFile": self.process_include,
             "CompositeRequirement": self.process_composite_requirement,
@@ -63,6 +66,9 @@ class SDocParsingProcessor:
                 )
         self.parse_context.document_grammar = document_grammar
 
+    def process_document_view(self, document_view: DocumentView):
+        self.parse_context.document_view = document_view
+
     def process_section(self, section: Section):
         section.ng_document_reference = self.parse_context.document_reference
 

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/reader.py

@@ -14,6 +14,7 @@ from strictdoc.backend.sdoc.models.constants import DOCUMENT_MODELS
 from strictdoc.backend.sdoc.models.document import Document
 from strictdoc.backend.sdoc.models.fragment import Fragment
 from strictdoc.backend.sdoc.processor import ParseContext, SDocParsingProcessor
+from strictdoc.backend.sdoc.validations.sdoc_validator import SDocValidator
 from strictdoc.helpers.cast import assert_cast
 from strictdoc.helpers.exception import StrictDocException
 from strictdoc.helpers.md5 import get_file_md5
@@ -65,17 +66,19 @@ class SDReader:
                 "  VALUE: REQ-1"
             )
 
+        return document, parse_context
+
+    @staticmethod
+    def read(input_string, file_path=None):
+        document, _ = SDReader._read(input_string, file_path)
+        SDocValidator.validate_document(document)
+
         # HACK:
         # ProcessPoolExecutor doesn't work because of non-picklable parts
         # of textx. The offending fields are stripped down because they
         # are not used anyway.
         drop_textx_meta(document)
 
-        return document, parse_context
-
-    @staticmethod
-    def read(input_string, file_path=None):
-        document, _ = SDReader._read(input_string, file_path)
         return document
 
     def read_from_file(self, file_path: str) -> Document:

strictdoc-0.0.49a4/strictdoc/backend/sdoc/validations/sdoc_validator.py

@@ -0,0 +1,67 @@
+from typing import Optional
+
+from textx import get_location
+
+from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
+from strictdoc.backend.sdoc.models.document import Document
+from strictdoc.backend.sdoc.models.document_config import DocumentConfig
+from strictdoc.backend.sdoc.models.document_view import DocumentView
+
+
+class SDocValidator:
+    """
+    This helper class is used for validating SDoc documents right after the
+    textX parsing and processing steps have finished.
+    FIXME: In the future, all processing validation steps could be moved to this
+           class as well. This would remove the need in the ParseContext class
+           and simplify several other implementation details.
+    """
+
+    @staticmethod
+    def validate_document(document: Document):
+        SDocValidator._validate_document_config(document)
+        SDocValidator._validate_document_view(document)
+
+    @staticmethod
+    def _validate_document_config(document: Document):
+        document_config: DocumentConfig = document.config
+        if document_config.default_view is not None:
+            if document.view is None:
+                raise StrictDocSemanticError.default_view_doesnt_exist(
+                    document_config.default_view,
+                    **get_location(document_config),
+                )
+            else:
+                view_names = map(
+                    lambda view_: view_.view_id, document.view.views
+                )
+                if document_config.default_view not in view_names:
+                    raise StrictDocSemanticError.default_view_doesnt_exist(
+                        document_config.default_view,
+                        **get_location(document_config),
+                    )
+
+    @staticmethod
+    def _validate_document_view(document: Document):
+        document_view: Optional[DocumentView] = document.view
+        if document_view is not None:
+            for view in document_view.views:
+                for tag in view.tags:
+                    if (
+                        tag.object_type
+                        not in document.grammar.registered_elements
+                    ):
+                        raise StrictDocSemanticError.view_references_nonexisting_grammar_element(
+                            view,
+                            tag.object_type,
+                            **get_location(document_view),
+                        )
+                    for field in tag.visible_fields:
+                        for grammar_element in document.grammar.elements:
+                            if field.name not in grammar_element.fields_map:
+                                raise StrictDocSemanticError.view_references_nonexisting_field(
+                                    view,
+                                    tag.object_type,
+                                    field.name,
+                                    **get_location(document_view),
+                                )

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/backend/sdoc/writer.py

@@ -8,6 +8,7 @@ from strictdoc.backend.sdoc.models.document_bibliography import (
 )
 from strictdoc.backend.sdoc.models.document_config import DocumentConfig
 from strictdoc.backend.sdoc.models.document_grammar import DocumentGrammar
+from strictdoc.backend.sdoc.models.document_view import DefaultViewElement
 from strictdoc.backend.sdoc.models.inline_link import InlineLink
 from strictdoc.backend.sdoc.models.reference import (
     BibReference,
@@ -138,9 +139,9 @@ class SDWriter:
                     output += "\n"
 
         document_view = document.view
-        if document_view is not None:
+        assert len(document_view.views) > 0
+        if not isinstance(document_view.views[0], DefaultViewElement):
             views = document_view.views
-            assert len(views) > 0
             output += "VIEWS:"
             output += "\n"
             for view in views:

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/cli/cli_arg_parser.py

@@ -128,6 +128,7 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         filter_sections: Optional[str],
         reqif_profile: Optional[str],
         experimental_enable_file_traceability,
+        view: Optional[str],
     ):
         assert isinstance(input_paths, list), f"{input_paths}"
         self.input_paths: List[str] = input_paths
@@ -144,6 +145,7 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         self.experimental_enable_file_traceability = (
             experimental_enable_file_traceability
         )
+        self.view: Optional[str] = view
         self.output_html_root: str = os.path.join(output_dir, "html")
 
     def get_path_to_config(self) -> Optional[str]:
@@ -267,6 +269,7 @@ class SDocArgsParser:
             self.args.filter_sections,
             self.args.reqif_profile,
             self.args.experimental_enable_file_traceability,
+            self.args.view,
         )
 
     def get_import_config_reqif(self, _) -> ImportReqIFCommandConfig:

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/cli/command_parser_builder.py

@@ -195,6 +195,11 @@ class CommandParserBuilder:
             type=str,
             help="Filter which sections will be exported.",
         )
+        command_parser_export.add_argument(
+            "--view",
+            type=str,
+            help="Choose which view will be exported.",
+        )
         add_config_argument(command_parser_export)
 
     @staticmethod

{strictdoc-0.0.49a2 → strictdoc-0.0.49a4}/strictdoc/core/project_config.py

@@ -136,6 +136,7 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
             datetime.datetime
         ] = config_last_update
         self.is_running_on_server: bool = False
+        self.view: Optional[str] = None
 
     @staticmethod
     def default_config(environment: SDocRuntimeEnvironment):
@@ -175,6 +176,7 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
         self.filter_requirements = export_config.filter_requirements
         self.filter_sections = export_config.filter_sections
         self.excel_export_fields = export_config.fields
+        self.view = export_config.view
 
         if (
             export_config.enable_mathjax