strictdoc 0.0.43a2__tar.gz → 0.0.43a4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.43a2
+Version: 0.0.43a4
 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.43a2 → strictdoc-0.0.43a4}/strictdoc/__init__.py

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

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

@@ -1,3 +1,5 @@
+from textx import TextXSyntaxError
+
 from strictdoc.backend.sdoc.models.document_grammar import (
     DocumentGrammar,
     GrammarElementField,
@@ -9,6 +11,10 @@ from strictdoc.backend.sdoc.models.requirement import (
 )
 
 
+def get_textx_syntax_error_message(exception: TextXSyntaxError):
+    return f"SDoc markup error: {exception.context}."
+
+
 class StrictDocSemanticError(Exception):
     def __init__(  # pylint: disable=too-many-arguments
         self, title, hint, example, line=None, col=None, filename=None

{strictdoc-0.0.43a2 → strictdoc-0.0.43a4}/strictdoc/backend/sdoc/grammar/grammar.py

@@ -1,6 +1,6 @@
 TEXT_TYPES_GRAMMAR = r"""
 TextPart[noskipws]:
-  (InlineLink | Anchor | NormalString)
+  (Anchor | InlineLink | NormalString)
 ;
 
 NormalString[noskipws]:
@@ -17,10 +17,31 @@ InlineLink[noskipws]:
   InlineLinkStart value = /[^\]]*/ ']'
 ;
 
-AnchorStart: '[ANCHOR: ';
+AnchorStart[noskipws]:
+  // Make sure that an anchor cannot follow right after a text string.
+  /(?<!\S\n)^/ '[ANCHOR: '
+;
 
 Anchor[noskipws]:
   AnchorStart value = /[^\],]*/ (', ' title = /\w+[\s\w+]*/)? ']'
+  // We expect either:
+  // - An anchor has a newline character after it, if this anchor is the last
+  //   part in the free text.
+  // - An anchor has two newline symbols, if this anchor is not the last part in
+  //   the free text.
+  // Furthermore, there are two cases of parsing free text with ANCHORs:
+  // 1) The full [FREETEXT] blocks inside SDoc files.
+  // 2) The inner free text blocks when only a single section is edited in UI.
+  // The resulting regex magic has three cases:
+  // 1) The ANCHOR has two newlines after it and something else follows it.
+  // 2) The ANCHOR has one newline and nothing else after it in an inner free
+  //    text block (\Z). A variation of this case is when there is no newline,
+  //    but only the end of the string (\Z).
+  // 3) The ANCHOR has one newline and then immediately the [/FREETEXT] ending
+  // block follows. (positive lookahead towards closing [/FREETEXT])
+  // '\\n' /(\\n|\Z)/
+   /\Z|(\n(\n|\Z|(?=\[\/FREETEXT\])))/
+
 ;
 
 FreeTextEnd: /^/ '[/FREETEXT]' '\n';

{strictdoc-0.0.43a2 → strictdoc-0.0.43a4}/strictdoc/backend/sdoc/grammar/type_system.py

@@ -5,7 +5,7 @@ FieldName[noskipws]:
 
 // According to the Strict Grammar Rule #3, both SingleLineString and
 // MultiLineString can never be empty strings.
-// Both must start with a non-space character.
+// Both must eventualy start with a non-space character.
 SingleLineString:
   (!MultiLineStringStart /\S/) (!MultiLineStringStart /./)* /$/
 ;
@@ -20,7 +20,7 @@ MultiLineStringEnd[noskipws]:
 
 MultiLineString[noskipws]:
   MultiLineStringStart-
-  (!MultiLineStringEnd /\S/) (!MultiLineStringEnd /(?ms)./)+
+  (!MultiLineStringEnd /\W*\S/) (!MultiLineStringEnd /(?ms)./)+
   MultiLineStringEnd-
 ;
 

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

@@ -318,7 +318,8 @@ class SDWriter:
     def print_free_text_content(free_text):
         assert isinstance(free_text, FreeText)
         output = ""
-        for part in free_text.parts:
+
+        for part_idx, part in enumerate(free_text.parts):
             if isinstance(part, str):
                 output += part
             elif isinstance(part, InlineLink):
@@ -332,6 +333,9 @@ class SDWriter:
                     output += ", "
                     output += part.title
                 output += "]"
+                output += "\n"
+                if part_idx != (len(free_text.parts) - 1):
+                    output += "\n"
             else:
                 raise NotImplementedError(part)
         return output

{strictdoc-0.0.43a2 → strictdoc-0.0.43a4}/strictdoc/core/commands/section.py

@@ -1,7 +1,10 @@
 from collections import defaultdict
 from typing import Dict, List, Optional, Union
 
+from textx import TextXSyntaxError
+
 from strictdoc.backend.sdoc.document_reference import DocumentReference
+from strictdoc.backend.sdoc.error_handling import get_textx_syntax_error_message
 from strictdoc.backend.sdoc.free_text_reader import SDFreeTextReader
 from strictdoc.backend.sdoc.models.anchor import Anchor
 from strictdoc.backend.sdoc.models.document import Document
@@ -58,30 +61,38 @@ class UpdateSectionCommand:
             ) = RstToHtmlFragmentWriter(
                 context_document=section.document
             ).write_with_validation(form_object.section_statement_unescaped)
+
             if parsed_html is None:
                 errors["section_statement"].append(rst_error)
             else:
-                free_text_container = SDFreeTextReader.read(
-                    form_object.section_statement_unescaped
-                )
-                anchors: List[Anchor] = []
-                for part in free_text_container.parts:
-                    if isinstance(part, InlineLink):
-                        # FIXME: Add validations.
-                        pass
-                    elif isinstance(part, Anchor):
-                        anchors.append(part)
-                    else:
-                        pass
-                if anchors is not None:
-                    try:
-                        traceability_index.validate_node_against_anchors(
-                            node=section, new_anchors=anchors
-                        )
-                    except SingleValidationError as anchors_validation_error:
-                        errors["section_statement"].append(
-                            anchors_validation_error.args[0]
-                        )
+                try:
+                    free_text_container = SDFreeTextReader.read(
+                        form_object.section_statement_unescaped
+                    )
+                    anchors: List[Anchor] = []
+                    for part in free_text_container.parts:
+                        if isinstance(part, InlineLink):
+                            # FIXME: Add validations.
+                            pass
+                        elif isinstance(part, Anchor):
+                            anchors.append(part)
+                        else:
+                            pass
+                    if anchors is not None:
+                        try:
+                            traceability_index.validate_node_against_anchors(
+                                node=section, new_anchors=anchors
+                            )
+                        except (
+                            SingleValidationError
+                        ) as anchors_validation_error:
+                            errors["section_statement"].append(
+                                anchors_validation_error.args[0]
+                            )
+                except TextXSyntaxError as exception:
+                    errors["section_statement"].append(
+                        get_textx_syntax_error_message(exception)
+                    )
         else:
             # If there is no free text, we need to check the anchors that may
             # have been in the existing free text.
@@ -93,6 +104,7 @@ class UpdateSectionCommand:
                 errors["section_statement"].append(
                     anchors_validation_error.args[0]
                 )
+
         if len(errors) > 0:
             raise validation_error
 
@@ -204,28 +216,34 @@ class CreateSectionCommand:
             if parsed_html is None:
                 errors["section_statement"].append(rst_error)
             else:
-                free_text_container = SDFreeTextReader.read(
-                    form_object.section_statement_unescaped
-                )
-                anchors: List[Anchor] = []
-                for part in free_text_container.parts:
-                    if isinstance(part, InlineLink):
-                        # FIXME: Add validations.
-                        pass
-                    elif isinstance(part, Anchor):
-                        anchors.append(part)
-                    else:
-                        pass
-                if anchors is not None:
-                    try:
-                        traceability_index.validate_node_against_anchors(
-                            node=None, new_anchors=anchors
-                        )
-                    except SingleValidationError as anchors_validation_error:
-                        errors["section_statement"].append(
-                            anchors_validation_error.args[0]
-                        )
-
+                try:
+                    free_text_container = SDFreeTextReader.read(
+                        form_object.section_statement_unescaped
+                    )
+                    anchors: List[Anchor] = []
+                    for part in free_text_container.parts:
+                        if isinstance(part, InlineLink):
+                            # FIXME: Add validations.
+                            pass
+                        elif isinstance(part, Anchor):
+                            anchors.append(part)
+                        else:
+                            pass
+                    if anchors is not None:
+                        try:
+                            traceability_index.validate_node_against_anchors(
+                                node=None, new_anchors=anchors
+                            )
+                        except (
+                            SingleValidationError
+                        ) as anchors_validation_error:
+                            errors["section_statement"].append(
+                                anchors_validation_error.args[0]
+                            )
+                except TextXSyntaxError as exception:
+                    errors["section_statement"].append(
+                        get_textx_syntax_error_message(exception)
+                    )
         if len(errors) > 0:
             raise validation_error
 

{strictdoc-0.0.43a2 → strictdoc-0.0.43a4}/strictdoc/core/commands/update_document_config.py

@@ -1,6 +1,9 @@
 from collections import defaultdict
 from typing import Dict, List, Optional
 
+from textx import TextXSyntaxError
+
+from strictdoc.backend.sdoc.error_handling import get_textx_syntax_error_message
 from strictdoc.backend.sdoc.free_text_reader import SDFreeTextReader
 from strictdoc.backend.sdoc.models.anchor import Anchor
 from strictdoc.backend.sdoc.models.document import Document
@@ -127,27 +130,34 @@ class UpdateDocumentConfigCommand:
             if parsed_html is None:
                 errors["FREETEXT"].append(rst_error)
             else:
-                free_text_container = SDFreeTextReader.read(
-                    form_object.document_freetext_unescaped
-                )
-                anchors: List[Anchor] = []
-                for part in free_text_container.parts:
-                    if isinstance(part, InlineLink):
-                        # FIXME: Add validations.
-                        pass
-                    elif isinstance(part, Anchor):
-                        anchors.append(part)
-                    else:
-                        pass
-                if anchors is not None:
-                    try:
-                        traceability_index.validate_node_against_anchors(
-                            node=document, new_anchors=anchors
-                        )
-                    except SingleValidationError as anchors_validation_error:
-                        errors["FREETEXT"].append(
-                            anchors_validation_error.args[0]
-                        )
+                try:
+                    free_text_container = SDFreeTextReader.read(
+                        form_object.document_freetext_unescaped
+                    )
+                    anchors: List[Anchor] = []
+                    for part in free_text_container.parts:
+                        if isinstance(part, InlineLink):
+                            # FIXME: Add validations.
+                            pass
+                        elif isinstance(part, Anchor):
+                            anchors.append(part)
+                        else:
+                            pass
+                    if anchors is not None:
+                        try:
+                            traceability_index.validate_node_against_anchors(
+                                node=document, new_anchors=anchors
+                            )
+                        except (
+                            SingleValidationError
+                        ) as anchors_validation_error:
+                            errors["FREETEXT"].append(
+                                anchors_validation_error.args[0]
+                            )
+                except TextXSyntaxError as exception:
+                    errors["FREETEXT"].append(
+                        get_textx_syntax_error_message(exception)
+                    )
         else:
             # If there is no free text, we need to check the anchors that may
             # have been in the existing free text.

strictdoc-0.0.43a4/strictdoc/export/dot/document_dot_generator.py

@@ -0,0 +1,301 @@
+import os
+import random
+from collections import defaultdict
+from pathlib import Path
+from typing import List, Optional, Union
+
+import graphviz
+
+from strictdoc.backend.sdoc.models.document import Document
+from strictdoc.backend.sdoc.models.requirement import Requirement
+from strictdoc.backend.sdoc.models.section import Section
+from strictdoc.core.document_iterator import DocumentCachingIterator
+from strictdoc.core.traceability_index import TraceabilityIndex
+from strictdoc.export.dot.dot_templates import DotTemplates
+
+
+def get_path_components(folder_path):
+    path = os.path.normpath(folder_path)
+    return path.split(os.sep)
+
+
+class DocumentDotGenerator:
+    def __init__(self, profile: str):
+        assert profile in ("profile1", "profile2"), profile
+        self.profile: str = profile
+        self.index_template = DotTemplates.jinja_environment.get_template(
+            f"{profile}/top_level.dot"
+        )
+        self.template_folder = DotTemplates.jinja_environment.get_template(
+            f"{profile}/folder.dot"
+        )
+        self.template_document = DotTemplates.jinja_environment.get_template(
+            f"{profile}/document.dot"
+        )
+        self.template_section = DotTemplates.jinja_environment.get_template(
+            f"{profile}/section.dot"
+        )
+        self.template_requirement = DotTemplates.jinja_environment.get_template(
+            f"{profile}/requirement.dot"
+        )
+
+    def export_tree(
+        self, traceability_index: TraceabilityIndex, output_dot_root
+    ):
+        Path(output_dot_root).mkdir(parents=True, exist_ok=True)
+
+        project_tree_content = ""
+
+        documents_by_folder = defaultdict(list)
+        for document in traceability_index.document_tree.document_list:
+            if not document.has_any_requirements():
+                continue
+            documents_by_folder[
+                document.meta.output_document_dir_rel_path
+            ].append(document)
+
+        accumulated_links = []
+        accumulated_section_siblings = []
+        document_flat_requirements = []
+        document: Document
+        for document_folder_idx, document_folder in enumerate(
+            documents_by_folder.keys()
+        ):
+            folder_documents = documents_by_folder[document_folder]
+            document_content = self._print_folder_documents(
+                document_folder,
+                document_folder_idx,
+                folder_documents,
+                accumulated_links,
+                accumulated_section_siblings,
+                document_flat_requirements,
+            )
+            project_tree_content += document_content
+            project_tree_content += "\n\n"
+
+        folders_idx = range(len(documents_by_folder))
+        folder_cluster_ids = list(
+            map(lambda f: f'"cluster_folder_anchor_{f}"', folders_idx)
+        )
+        folders_link_string = " -> ".join(folder_cluster_ids)
+
+        def random_color():
+            # https://graphviz.org/doc/info/colors.html
+            return random.choice(
+                [
+                    "red",
+                    "forestgreen",
+                    "green",
+                    "blue",
+                    "gray10",
+                    "turquoise",
+                    "sienna",
+                    "indigo",
+                    "lightseagreen",
+                    "olive",
+                    "teal",
+                    "webpurple",
+                    "webmaroon",
+                    "slateblue1",
+                ]
+            )
+
+        dot_output = self.index_template.render(
+            project_tree_content=project_tree_content,
+            accumulated_links=accumulated_links,
+            accumulated_section_siblings=accumulated_section_siblings,
+            document_flat_requirements=document_flat_requirements,
+            random_color=random_color,
+            folders_link_string=folders_link_string,
+        )
+
+        output_path = os.path.join(
+            output_dot_root, f"output.{self.profile}.dot"
+        )
+        with open(output_path, "w", encoding="utf8") as file:
+            file.write(dot_output)
+
+        dot = graphviz.Source.from_file(output_path)
+        # view=True makes the output PDF be opened in a default viewer program.
+        dot.render(output_path, view=False)
+
+    def _print_folder_documents(
+        self,
+        folder_name,
+        folder_idx,
+        folder_documents: List[Document],
+        accumulated_links,
+        accumulated_section_siblings,
+        document_flat_requirements,
+    ):
+        def get_bottom_most_section(document: Document) -> Optional[Section]:
+            current_node: Union[Document, Section] = document
+            candidate_section: Optional[Section] = None
+            while len(current_node.section_contents) > 0:
+                for subnode in reversed(current_node.section_contents):
+                    if isinstance(subnode, Section):
+                        candidate_section = subnode
+                        current_node = subnode
+                        break
+                else:
+                    break
+            return candidate_section
+
+        folder_documents_content = ""
+        for document_idx, document in enumerate(folder_documents):
+            assert document.has_any_requirements()
+
+            document_content = self._print_document(
+                document,
+                folder_idx,
+                document_idx,
+                accumulated_links,
+                accumulated_section_siblings,
+                document_flat_requirements,
+            )
+            folder_documents_content += document_content
+            folder_documents_content += "\n\n"
+
+            if document_idx > 0:
+                prev_document = folder_documents[document_idx - 1]
+                prev_document_last_section = get_bottom_most_section(
+                    prev_document
+                )
+                if prev_document_last_section is None:
+                    continue
+
+                lhs_node_id = document.section_contents[0].node_id
+                if not isinstance(document.section_contents[0], Section):
+                    lhs_node_id = document.node_id
+
+                rhs_node_id = prev_document_last_section.node_id
+
+                accumulated_section_siblings.append((lhs_node_id, rhs_node_id))
+
+        dot_output = self.template_folder.render(
+            folder_name=folder_name,
+            folder_idx=folder_idx,
+            folder_documents_content=folder_documents_content,
+        )
+        return dot_output
+
+    def _print_document(
+        self,
+        document: Document,
+        folder_idx,
+        document_idx,
+        accumulated_links,
+        accumulated_section_siblings,
+        document_flat_requirements,
+    ) -> str:
+        document_content = self._print_node(
+            document, accumulated_links, accumulated_section_siblings
+        )
+
+        this_document_flat_requirements = []
+
+        iterator = DocumentCachingIterator(document)
+        for node in iterator.all_content():
+            if isinstance(node, Requirement):
+                uuid = self.get_requirement_uuid(node)
+
+                this_document_flat_requirements.append(f'"value_{uuid}"')
+
+        this_document_flat_requirements_str = (
+            " -> ".join(this_document_flat_requirements)
+            if len(this_document_flat_requirements) > 1
+            else None
+        )
+        document_flat_requirements.append(this_document_flat_requirements_str)
+
+        return self.template_document.render(
+            document=document,
+            document_idx=document_idx,
+            folder_idx=folder_idx,
+            document_content=document_content,
+        )
+
+    def _print_node(
+        self,
+        node: Union[Document, Section],
+        accumulated_links,
+        accumulated_section_siblings,
+    ) -> str:
+        def get_uuid(node_):
+            return node_.node_id
+
+        def get_upper_sibling_section(node_: Section):
+            parent: Union[Document, Section] = node_.parent
+            node_index = parent.section_contents.index(node_)
+            if node_index > 0:
+                candidate_upper_sibling = parent.section_contents[
+                    node_index - 1
+                ]
+                if isinstance(candidate_upper_sibling, Section):
+                    return candidate_upper_sibling
+            return None
+
+        node_content = ""
+        for subnode in node.section_contents:
+            if isinstance(subnode, Section):
+                node_content += self._print_node(
+                    subnode, accumulated_links, accumulated_section_siblings
+                )
+                node_content += "\n"
+
+                upper_sibling_section = get_upper_sibling_section(subnode)
+                if upper_sibling_section is not None:
+                    accumulated_section_siblings.append(
+                        (get_uuid(subnode), get_uuid(upper_sibling_section))
+                    )
+            elif isinstance(subnode, Requirement):
+                node_content += self._print_requirement_fields(
+                    subnode, accumulated_links
+                )
+                node_content += "\n"
+        output = self.template_section.render(
+            section=node,
+            uuid=get_uuid(node),
+            node_content=node_content,
+            font_size=32 - node.ng_level * 4,
+            context_title=f"{node.context.title_number_string} {node.title}"
+            if isinstance(node, Section)
+            else node.title,
+        )
+        return output
+
+    def _print_requirement_fields(
+        self, requirement: Requirement, accumulated_links
+    ):
+        def get_color_from_status(requirement_: Requirement):
+            if requirement_.reserved_status is None:
+                return "#87CEEB", "filled,rounded,dashed", "box", "\\l"
+            if requirement_.reserved_status == "Draft":
+                return "gray", "filled", "diamond", ""
+            if requirement_.reserved_status == "Backlog":
+                return "lightgray", "filled,rounded,dashed", "box", "\\l"
+            if requirement_.reserved_status == "Progress":
+                return "yellow", "filled,rounded,solid", "box", "\\l"
+            if requirement_.reserved_status in ("Active", "Implemented"):
+                return "white", "filled,rounded,solid", "box", "\\l"
+            raise NotImplementedError(requirement.reserved_status)
+
+        uuid = self.get_requirement_uuid(requirement)
+        for parent_uid in requirement.get_parent_requirement_reference_uids():
+            accumulated_links.append((uuid, parent_uid))
+
+        output = self.template_requirement.render(
+            requirement=requirement,
+            uuid=uuid,
+            requirement_color=get_color_from_status(requirement),
+        )
+        return output
+
+    @staticmethod
+    def get_requirement_uuid(requirement: Requirement):
+        assert isinstance(requirement, Requirement)
+        return (
+            requirement.reserved_uid
+            if requirement.reserved_uid is not None
+            else requirement.node_id
+        )

strictdoc-0.0.43a4/strictdoc/export/dot/templates/profile1/document.dot

@@ -0,0 +1,12 @@
+subgraph "cluster_{{folder_idx}}_document_{{document_idx}}" {
+  label = "";
+  penwidth=0;
+
+  // This is currently only used to orient: Legend -> First Document.
+  "anchor_cluster_{{folder_idx}}_document_{{document_idx}}" [shape="point", width=1, height=1, fillcolor=red, style=invis];
+
+{% filter indent(width=2) %}
+{{document_content}}
+{% endfilter %}
+
+}

strictdoc-0.0.43a4/strictdoc/export/dot/templates/profile1/folder.dot

@@ -0,0 +1,15 @@
+subgraph "cluster_folder_{{folder_idx}}" {
+  label = "{{folder_name}}";
+  fontsize = 32;
+  fontname="Arial-bold";
+  penwidth=1;
+  style="rounded";
+
+"cluster_folder_anchor_{{folder_idx}}" [shape="point", width=1, height=1, style="invis"];
+
+{% filter indent(width=2) %}
+{{folder_documents_content}}
+{% endfilter %}
+
+}
+