strictdoc 0.0.53__tar.gz → 0.0.54__tar.gz

{strictdoc-0.0.53 → strictdoc-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.53
+Version: 0.0.54
 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.53 → strictdoc-0.0.54}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.0.53"
+__version__ = "0.0.54"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/models/document.py

@@ -9,6 +9,12 @@ from strictdoc.helpers.auto_described import auto_described
 from strictdoc.helpers.mid import MID
 
 
+@auto_described
+class SDocDocumentContext:
+    def __init__(self):
+        self.title_number_string = None
+
+
 @auto_described
 class SDocDocument:  # pylint: disable=too-many-instance-attributes
     def __init__(
@@ -44,16 +50,45 @@ class SDocDocument:  # pylint: disable=too-many-instance-attributes
         self.ng_needs_generation = False
         self.ng_uses_old_refs_field: bool = False
         self.ng_at_least_one_relations_field: bool = False
+        self.ng_has_requirements = False
 
         self.meta: Optional[DocumentMeta] = None
 
         self.reserved_mid: MID = MID(mid) if mid is not None else MID.create()
         self.mid_permanent: bool = mid is not None
         self.included_documents: List["SDocDocument"] = []
+        self.context = SDocDocumentContext()
 
         self.ng_including_document_reference: Optional = None
+        self.ng_including_document_from_file: Optional = None
+
+    @property
+    def uid(self) -> Optional[str]:
+        return self.config.uid
+
+    @property
+    def is_section(self):
+        return True
+
+    @property
+    def is_root_included_document(self):
+        return self.document_is_included()
+
+    @property
+    def is_requirement(self):
+        return False
+
+    @property
+    def is_composite_requirement(self):
+        return False
 
-    def document_is_included(self):
+    def get_node_type_string(self) -> Optional[str]:
+        return None
+
+    def get_type_string(self) -> str:
+        return "document" if not self.document_is_included() else "section"
+
+    def document_is_included(self) -> bool:
         return self.ng_including_document_reference.get_document() is not None
 
     def get_included_document(self):
@@ -101,14 +136,14 @@ class SDocDocument:  # pylint: disable=too-many-instance-attributes
     def get_title(self):
         return self.title
 
-    @staticmethod
-    def get_type_string() -> str:
-        return "document"
-
     @property
     def ng_resolved_custom_level(self):
         return None
 
+    @property
+    def requirement_prefix(self) -> str:
+        return self.get_requirement_prefix()
+
     def get_requirement_prefix(self) -> str:
         return self.config.get_requirement_prefix()
 

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/models/document_from_file.py

@@ -1,7 +1,6 @@
 from typing import List, Optional
 
 from strictdoc.backend.sdoc.document_reference import DocumentReference
-from strictdoc.backend.sdoc.models.section import SDocSection
 from strictdoc.helpers.auto_described import auto_described
 
 
@@ -19,9 +18,9 @@ class DocumentFromFile:
         self.ng_document_reference: Optional[DocumentReference] = None
         self.ng_included_document_reference: Optional[DocumentReference] = None
         self.ng_resolved_custom_level = None
+        self.ng_whitelisted = True
         self.resolved_full_path_to_document_file = None
         self.resolved_document: Optional = None
-        self.top_section: Optional = None
 
     @property
     def document(self):
@@ -42,25 +41,27 @@ class DocumentFromFile:
 
     @property
     def section_contents(self) -> List:
-        return [self.top_section]
+        return [self.resolved_document]
 
-    def configure_with_resolved_document(self, document):
-        assert document is not None
-        self.resolved_document = document
-
-        top_section = SDocSection(
-            self,
-            mid=None,
-            uid=None,
-            custom_level=None,
-            title=self.resolved_document.title,
-            requirement_prefix=self.resolved_document.get_requirement_prefix(),
-            free_texts=self.resolved_document.free_texts,
-            section_contents=self.resolved_document.section_contents,
-            root_section=True,
-        )
+    def configure_with_resolved_document(self, resolved_document):
         assert self.ng_included_document_reference is None
         assert self.ng_document_reference is not None
-        top_section.ng_document_reference = self.ng_document_reference
-        top_section.ng_including_document_reference = self.ng_document_reference
-        self.top_section = top_section
+
+        assert resolved_document is not None
+        self.resolved_document = resolved_document
+
+        including_document_or_section = self.parent
+
+        if including_document_or_section.__class__.__name__ == "SDocDocument":
+            including_document = including_document_or_section
+        elif including_document_or_section.__class__.__name__ == "SDocSection":
+            including_document = including_document_or_section.document
+        else:
+            raise AssertionError(including_document_or_section)
+
+        resolved_document.ng_including_document_from_file = self
+        resolved_document.ng_including_document_reference.set_document(
+            including_document
+        )
+
+        including_document.included_documents.append(resolved_document)

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/models/node.py

@@ -223,6 +223,10 @@ class SDocNode(SDocObject):
     def get_title(self):
         return self.reserved_title
 
+    @property
+    def is_root_included_document(self):
+        return False
+
     @property
     def is_root(self) -> bool:
         return self.document.config.root is True

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/models/section.py

@@ -70,6 +70,10 @@ class SDocSection(SDocObject):  # pylint: disable=too-many-instance-attributes
     def get_node_type_string(self) -> Optional[str]:
         return None
 
+    @property
+    def is_root_included_document(self):
+        return False
+
     def get_title(self):
         return self.title
 

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/pickle_cache.py

@@ -12,7 +12,7 @@ class PickleCache:
 
         full_path_to_file = (
             file_path
-            if os.path.abspath(file_path)
+            if os.path.isabs(file_path)
             else os.path.abspath(file_path)
         )
 

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/processor.py

@@ -38,6 +38,7 @@ class ParseContext:
         self.document_view: Optional[DocumentView] = None
         self.uses_old_refs_field: bool = False
         self.at_least_one_relations_field: bool = False
+        self.document_has_requirements = False
 
         # FIXME: Plain list of all fragments found in the document.
         self.fragments_from_files: List = []
@@ -168,6 +169,8 @@ class SDocParsingProcessor:
     def process_composite_requirement(
         self, composite_requirement: SDocCompositeNode
     ):
+        self.parse_context.document_has_requirements = True
+
         if self.parse_context.document_config.auto_levels:
             if composite_requirement.ng_resolved_custom_level:
                 raise StrictDocException(
@@ -207,6 +210,8 @@ class SDocParsingProcessor:
             composite_requirement.ng_resolved_custom_level = "None"
 
     def process_requirement(self, requirement: SDocNode):
+        self.parse_context.document_has_requirements = True
+
         if requirement.ng_uses_old_refs_field:
             self.parse_context.uses_old_refs_field = True
         elif "REFS" in requirement.ordered_fields_lookup:

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/reader.py

@@ -38,6 +38,7 @@ class SDReader:
             input_string, file_name=file_path
         )
         parse_context.document_reference.set_document(document)
+        document.ng_has_requirements = parse_context.document_has_requirements
         document.ng_uses_old_refs_field = parse_context.uses_old_refs_field
         document.ng_at_least_one_relations_field = (
             parse_context.at_least_one_relations_field

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/backend/sdoc/writer.py

@@ -1,7 +1,7 @@
 import os.path
 from enum import Enum
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from strictdoc.backend.sdoc.models.anchor import Anchor
 from strictdoc.backend.sdoc.models.document import SDocDocument
@@ -201,107 +201,124 @@ class SDWriter:
         document_grammar: DocumentGrammar = document.grammar
         if not document_grammar.is_default:
             output += "\n[GRAMMAR]\n"
-            output += "ELEMENTS:\n"
-            for element in document_grammar.elements:
-                output += "- TAG: "
-                output += element.tag
-                output += "\n  FIELDS:\n"
-                refs_field: Optional[GrammarElementFieldReference] = None
-                for grammar_field in element.fields:
-                    if grammar_field.title == "REFS":
-                        refs_field = assert_cast(
-                            grammar_field, GrammarElementFieldReference
+            if document_grammar.import_from_file is not None:
+                output += (
+                    f"IMPORT_FROM_FILE: {document_grammar.import_from_file}\n"
+                )
+            else:
+                output += "ELEMENTS:\n"
+                for element in document_grammar.elements:
+                    output += "- TAG: "
+                    output += element.tag
+                    output += "\n  FIELDS:\n"
+                    refs_field: Optional[GrammarElementFieldReference] = None
+                    for grammar_field in element.fields:
+                        if grammar_field.title == "REFS":
+                            refs_field = assert_cast(
+                                grammar_field, GrammarElementFieldReference
+                            )
+                            continue
+                        output += SDWriter._print_grammar_field_type(
+                            grammar_field
                         )
-                        continue
-                    output += SDWriter._print_grammar_field_type(grammar_field)
 
-                relations: List = element.relations
-                assert len(relations) > 0, relations
+                    relations: List = element.relations
+                    assert len(relations) > 0, relations
 
-                # For backward compatibility, we print RELATIONS from REFS
-                # grammar field if it exists.
-                if not document_grammar.is_default and refs_field is not None:
-                    relations = refs_field.convert_to_relations()
-                output += "  RELATIONS:\n"
+                    # For backward compatibility, we print RELATIONS from REFS
+                    # grammar field if it exists.
+                    if (
+                        not document_grammar.is_default
+                        and refs_field is not None
+                    ):
+                        relations = refs_field.convert_to_relations()
+                    output += "  RELATIONS:\n"
 
-                assert len(relations) > 0, relations
-                for element_relation in relations:
-                    output += f"  - TYPE: {element_relation.relation_type}\n"
-                    if element_relation.relation_role is not None:
+                    assert len(relations) > 0, relations
+                    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"
             output += self._print_free_text(free_text)
 
-        output += self._print_body(document, document, document_iterator)
+        output += "\n"
+
+        output += self._print_node(document, document, document_iterator)
+
+        output = output.rstrip()
+        output += "\n"
 
         return output, fragments_dict
 
-    def _print_body(
+    def _print_node(
         self,
-        root_node: SDocDocument,
+        root_node: Union[SDocDocument, SDocSection, SDocNode, DocumentFromFile],
         document: SDocDocument,
         document_iterator: DocumentCachingIterator,
     ):
-        assert isinstance(root_node, SDocDocument), root_node
         assert isinstance(
             document_iterator, DocumentCachingIterator
         ), document_iterator
 
-        output = ""
+        if isinstance(root_node, SDocDocument):
+            output = ""
 
-        closing_tags = []
-        for content_node in document_iterator.all_content(
-            print_fragments=False, print_fragments_from_files=True
-        ):
-            if isinstance(content_node, DocumentFromFile):
-                document_from_file: DocumentFromFile = assert_cast(
-                    content_node, DocumentFromFile
+            for node_ in root_node.section_contents:
+                if not node_.ng_whitelisted:
+                    continue
+                output += self._print_node(
+                    node_, document, document_iterator=document_iterator
                 )
-                output += "\n"
-                output += self._print_document_from_file(document_from_file)
+            return output
 
-                continue
+        if isinstance(root_node, DocumentFromFile):
+            document_from_file: DocumentFromFile = assert_cast(
+                root_node, DocumentFromFile
+            )
+            return self._print_document_from_file(document_from_file)
 
-            while (
-                len(closing_tags) > 0
-                and content_node.ng_level <= closing_tags[-1][1]
-            ):
-                closing_tag, _ = closing_tags.pop()
-                output += self._print_closing_tag(closing_tag)
+        if isinstance(root_node, SDocSection):
+            return self._print_section(root_node, document, document_iterator)
 
-            output += "\n"
+        elif isinstance(root_node, SDocNode):
+            output = ""
+            if isinstance(root_node, SDocCompositeNode):
+                output += "[COMPOSITE_"
+                output += root_node.requirement_type
+                output += "]\n"
+            else:
+                output += "["
+                output += root_node.requirement_type
+                output += "]\n"
 
-            if not content_node.ng_whitelisted:
-                continue
+            output += self._print_requirement_fields(
+                section_content=root_node, document=document
+            )
+            output += "\n"
 
-            elif isinstance(content_node, SDocSection):
-                output += self._print_section(content_node, document)
-                closing_tags.append((TAG.SECTION, content_node.ng_level))
-            elif isinstance(content_node, SDocNode):
-                if isinstance(content_node, SDocCompositeNode):
-                    output += "[COMPOSITE_"
-                    output += content_node.requirement_type
-                    output += "]\n"
-                    closing_tags.append(
-                        (TAG.COMPOSITE_REQUIREMENT, content_node.ng_level)
+            if isinstance(root_node, SDocCompositeNode):
+                for node_ in root_node.requirements:
+                    if not node_.ng_whitelisted:
+                        continue
+                    output += self._print_node(
+                        node_, document, document_iterator=document_iterator
                     )
-                else:
-                    output += "["
-                    output += content_node.requirement_type
-                    output += "]\n"
 
-                output += self._print_requirement_fields(
-                    section_content=content_node, document=document
-                )
+                output += "[/COMPOSITE_"
+                output += root_node.requirement_type
+                output += "]\n"
+                output += "\n"
 
-        for closing_tag, _ in reversed(closing_tags):
-            output += self._print_closing_tag(closing_tag)
+            return output
 
-        return output
+        raise AssertionError("Must not reach here")
 
     def _print_document_from_file(self, document_from_file: DocumentFromFile):
         assert isinstance(document_from_file, DocumentFromFile)
@@ -311,11 +328,16 @@ class SDWriter:
 
         output += "FILE: "
         output += document_from_file.file
-        output += "\n"
+        output += "\n\n"
 
         return output
 
-    def _print_section(self, section: SDocSection, document: SDocDocument):
+    def _print_section(
+        self,
+        section: SDocSection,
+        document: SDocDocument,
+        iterator: DocumentCachingIterator,
+    ):
         assert isinstance(section, SDocSection)
         output = ""
         output += "[SECTION]"
@@ -347,6 +369,16 @@ class SDWriter:
         for free_text in section.free_texts:
             output += "\n"
             output += self._print_free_text(free_text)
+        output += "\n"
+
+        for node_ in section.section_contents:
+            output += self._print_node(
+                node_, document, document_iterator=iterator
+            )
+
+        output += "[/SECTION]"
+        output += "\n\n"
+
         return output
 
     @staticmethod

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/cli/cli_arg_parser.py

@@ -162,11 +162,15 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         return path_to_config
 
     def validate(self):
-        for input_path_ in self.input_paths:
+        for idx_, input_path_ in enumerate(self.input_paths.copy()):
             if not os.path.exists(input_path_):
                 raise CLIValidationError(
                     f"Provided input path does not exist: {input_path_}"
                 )
+            if not os.path.isabs(input_path_):
+                self.input_paths[idx_] = os.path.abspath(input_path_).rstrip(
+                    "/"
+                )
         if self._config_path is not None:
             if not os.path.exists(self._config_path):
                 raise CLIValidationError(

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/core/document_finder.py

@@ -192,8 +192,12 @@ class DocumentFinder:
 
             # Finding assets.
             tree_asset_dirs = PathFinder.find_directories(
-                path_to_doc_root, "_assets"
+                path_to_doc_root,
+                "_assets",
+                include_paths=project_config.include_doc_paths,
+                exclude_paths=project_config.exclude_doc_paths,
             )
+
             for asset_dir in tree_asset_dirs:
                 asset_dirs.append(
                     {

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/core/document_iterator.py

@@ -47,6 +47,21 @@ class DocumentCachingIterator:
             custom_level=not root_node.config.auto_levels,
         )
 
+    def all_content_from_node(
+        self,
+        node,
+        print_fragments: bool = False,
+        print_fragments_from_files: bool = False,
+    ):
+        document = node if isinstance(node, SDocDocument) else node.document
+        yield from self._all_content(
+            node,
+            print_fragments=print_fragments,
+            print_fragments_from_files=print_fragments_from_files,
+            level_stack=(),
+            custom_level=not document.config.auto_levels,
+        )
+
     def _all_content(
         self,
         node,
@@ -135,6 +150,18 @@ class DocumentCachingIterator:
             yield node
 
         elif isinstance(node, SDocDocument):
+            if (
+                print_fragments
+                and node.document_is_included()
+                and self.document != node
+            ):
+                node.context.title_number_string = ".".join(
+                    map(str, level_stack)
+                )
+                node.ng_level = len(level_stack)
+
+                yield node
+
             current_number = 0
             for subnode_ in node.section_contents:
                 if subnode_.ng_resolved_custom_level is None:
@@ -155,7 +182,7 @@ class DocumentCachingIterator:
                 return
 
             yield from self._all_content(
-                node.top_section,
+                node.resolved_document,
                 print_fragments=print_fragments,
                 print_fragments_from_files=print_fragments_from_files,
                 level_stack=level_stack,

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/core/file_tree.py

@@ -164,7 +164,8 @@ class FileFinder:
         exclude_paths: List[str],
     ):
         assert os.path.isdir(root_path)
-        assert os.path.isabs(root_path)
+        assert os.path.isabs(root_path), root_path
+        assert not root_path.endswith("/"), root_path
 
         extensions_tuple = tuple(extensions) if extensions is not None else ()
 
@@ -247,7 +248,10 @@ class FileFinder:
             current_parent_path = os.path.dirname(current_root_path)
 
             # top-down search assumes we have seen the parent before.
-            assert current_parent_path in folder_map
+            assert current_parent_path in folder_map, (
+                current_parent_path,
+                folder_map,
+            )
 
             current_parent_folder: Folder = folder_map[current_parent_path]
             current_tree.set_parent_folder(current_parent_folder)
@@ -270,11 +274,38 @@ class FileFinder:
 
 class PathFinder:
     @staticmethod
-    def find_directories(root_path, directory):
+    def find_directories(
+        root_path, directory, include_paths: List[str], exclude_paths: List[str]
+    ):
         assert os.path.isdir(root_path)
         assert os.path.isabs(root_path)
+
+        path_filter_includes = PathFilter(
+            include_paths, positive_or_negative=True
+        )
+        path_filter_excludes = PathFilter(
+            exclude_paths, positive_or_negative=False
+        )
+
         directories = []
+        # Declare str type to make os.path.relpath type checking happy.
+        current_root_path: str
         for current_root_path, dirs, _ in os.walk(root_path, topdown=True):
+            current_root_relative_path: str = os.path.relpath(
+                current_root_path, start=root_path
+            )
+            current_root_relative_path = (
+                current_root_relative_path
+                if current_root_relative_path != "."
+                else ""
+            )
+
+            if path_filter_excludes.match(current_root_relative_path):
+                continue
+
+            if not path_filter_includes.match(current_root_relative_path):
+                continue
+
             dirs[:] = [
                 d
                 for d in dirs
@@ -285,6 +316,8 @@ class PathFinder:
                 and d != "Output"
                 and d != "tests"
             ]
+
             if os.path.basename(current_root_path) == directory:
                 directories.append(current_root_path)
+
         return directories

{strictdoc-0.0.53 → strictdoc-0.0.54}/strictdoc/core/finders/source_files_finder.py

@@ -133,7 +133,11 @@ class SourceFilesFinder:
         found_source_files: List[SourceFile] = []
 
         # TODO: Unify this on the FileTree class level.
-        doctree_root_abs_path = project_config.source_root_path
+        doctree_root_abs_path = (
+            project_config.source_root_path
+            if project_config.source_root_path is not None
+            else os.getcwd()
+        )
         doctree_root_abs_path = (
             os.path.dirname(doctree_root_abs_path)
             if os.path.isfile(doctree_root_abs_path)