strictdoc 0.1.0__tar.gz → 0.2.0__tar.gz

{strictdoc-0.1.0 → strictdoc-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strictdoc
-Version: 0.1.0
+Version: 0.2.0
 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.1.0 → strictdoc-0.2.0}/strictdoc/__init__.py

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

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc/grammar_reader.py

@@ -12,6 +12,7 @@ from strictdoc.backend.sdoc.models.document_grammar import (
     DocumentGrammarWrapper,
 )
 from strictdoc.backend.sdoc.pickle_cache import PickleCache
+from strictdoc.core.project_config import ProjectConfig
 from strictdoc.helpers.cast import assert_optional_cast
 from strictdoc.helpers.textx import (
     drop_textx_meta,
@@ -26,9 +27,6 @@ class SDocGrammarReader:
         use_regexp_group=True,
     )
 
-    def __init__(self, path_to_output_root: str) -> None:
-        self.path_to_output_root: str = path_to_output_root
-
     @staticmethod
     def read(
         input_string: str, file_path: Optional[str] = None
@@ -60,9 +58,11 @@ class SDocGrammarReader:
 
         return grammar
 
-    def read_from_file(self, file_path: str) -> DocumentGrammar:
+    def read_from_file(
+        self, file_path: str, project_config: ProjectConfig
+    ) -> DocumentGrammar:
         unpickled_content: Optional[DocumentGrammar] = assert_optional_cast(
-            PickleCache.read_from_cache(file_path, self.path_to_output_root),
+            PickleCache.read_from_cache(file_path, project_config, "grammar"),
             DocumentGrammar,
         )
         if unpickled_content is not None:
@@ -76,7 +76,7 @@ class SDocGrammarReader:
                 grammar_content, file_path=file_path
             )
             PickleCache.save_to_cache(
-                grammar, file_path, self.path_to_output_root
+                grammar, file_path, project_config, "grammar"
             )
 
             return grammar

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc/pickle_cache.py

@@ -1,18 +1,20 @@
 import hashlib
 import os
-import tempfile
 from pathlib import Path
 from typing import Any
 
+from strictdoc.core.project_config import ProjectConfig
 from strictdoc.helpers.md5 import get_file_md5
 from strictdoc.helpers.pickle import pickle_dump, pickle_load
 
 
 class PickleCache:
     @staticmethod
-    def read_from_cache(file_path: str, path_to_root: str) -> Any:
+    def read_from_cache(
+        file_path: str, project_config: ProjectConfig, content_kind: str
+    ) -> Any:
         path_to_cached_file: str = PickleCache.get_cached_file_path(
-            file_path, path_to_root
+            file_path, project_config, content_kind
         )
         if os.path.isfile(path_to_cached_file):
             with open(path_to_cached_file, "rb") as cache_file:
@@ -30,9 +32,14 @@ class PickleCache:
         return None
 
     @staticmethod
-    def save_to_cache(content: Any, file_path: str, path_to_root: str) -> None:
+    def save_to_cache(
+        content: Any,
+        file_path: str,
+        project_config: ProjectConfig,
+        content_kind: str,
+    ) -> None:
         path_to_cached_file: str = PickleCache.get_cached_file_path(
-            file_path, path_to_root
+            file_path, project_config, content_kind
         )
         path_to_cached_file_dir: str = os.path.dirname(path_to_cached_file)
         Path(path_to_cached_file_dir).mkdir(parents=True, exist_ok=True)
@@ -41,8 +48,10 @@ class PickleCache:
             cache_file.write(pickled_content)
 
     @staticmethod
-    def get_cached_file_path(file_path: str, path_to_output_root: str) -> str:
-        path_to_tmp_dir = tempfile.gettempdir()
+    def get_cached_file_path(
+        file_path: str, project_config: ProjectConfig, content_kind: str
+    ) -> str:
+        path_to_tmp_dir = project_config.get_path_to_cache_dir()
 
         full_path_to_file = (
             file_path
@@ -57,7 +66,7 @@ class PickleCache:
         # contains a full path to the output root to prevent collisions
         # between StrictDoc invocations running against the same set of SDoc
         # files in parallel.
-        unique_identifier = path_to_output_root + full_path_to_file
+        unique_identifier = project_config.output_dir + full_path_to_file
         unique_identifier_md5 = hashlib.md5(
             unique_identifier.encode("utf-8")
         ).hexdigest()
@@ -66,7 +75,7 @@ class PickleCache:
 
         path_to_cached_file = os.path.join(
             path_to_tmp_dir,
-            "strictdoc_cache",
+            content_kind,
             file_name,
         )
 

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc/reader.py

@@ -11,6 +11,7 @@ from strictdoc.backend.sdoc.models.constants import DOCUMENT_MODELS
 from strictdoc.backend.sdoc.models.document import SDocDocument
 from strictdoc.backend.sdoc.pickle_cache import PickleCache
 from strictdoc.backend.sdoc.processor import ParseContext, SDocParsingProcessor
+from strictdoc.core.project_config import ProjectConfig
 from strictdoc.helpers.cast import assert_cast
 from strictdoc.helpers.exception import StrictDocException
 from strictdoc.helpers.textx import drop_textx_meta
@@ -23,9 +24,6 @@ class SDReader:
         use_regexp_group=True,
     )
 
-    def __init__(self, path_to_output_root: str = "NOT_RELEVANT"):
-        self.path_to_output_root = path_to_output_root
-
     @staticmethod
     def _read(input_string, file_path=None):
         parse_context = ParseContext(path_to_sdoc_file=file_path)
@@ -54,14 +52,16 @@ class SDReader:
         document, parse_context = SDReader._read(input_string, file_path)
         return document, parse_context
 
-    def read_from_file(self, file_path: str) -> SDocDocument:
+    def read_from_file(
+        self, file_path: str, project_config: ProjectConfig
+    ) -> SDocDocument:
         """
         This function parses the provided .sdoc file and returns a Document
         object.
         """
 
         unpickled_content = PickleCache.read_from_cache(
-            file_path, self.path_to_output_root
+            file_path, project_config, "sdoc"
         )
         if unpickled_content:
             return assert_cast(unpickled_content, SDocDocument)
@@ -82,7 +82,7 @@ class SDReader:
             # are not used anyway.
             drop_textx_meta(sdoc)
 
-            PickleCache.save_to_cache(sdoc, file_path, self.path_to_output_root)
+            PickleCache.save_to_cache(sdoc, file_path, project_config, "sdoc")
 
             return sdoc
         except StrictDocException as exception:

strictdoc-0.2.0/strictdoc/backend/sdoc_source_code/caching_reader.py

@@ -0,0 +1,59 @@
+from typing import Union
+
+from strictdoc.backend.sdoc.pickle_cache import PickleCache
+from strictdoc.backend.sdoc_source_code.models.source_file_info import (
+    SourceFileTraceabilityInfo,
+)
+from strictdoc.backend.sdoc_source_code.reader import (
+    SourceFileTraceabilityReader,
+)
+from strictdoc.backend.sdoc_source_code.reader_c import (
+    SourceFileTraceabilityReader_C,
+)
+from strictdoc.backend.sdoc_source_code.reader_python import (
+    SourceFileTraceabilityReader_Python,
+)
+from strictdoc.core.project_config import ProjectConfig
+
+
+class SourceFileTraceabilityCachingReader:
+    @staticmethod
+    def read_from_file(
+        path_to_file: str, project_config: ProjectConfig
+    ) -> SourceFileTraceabilityInfo:
+        unpickled_content = PickleCache.read_from_cache(
+            path_to_file, project_config, "source_file"
+        )
+        if unpickled_content is not None:
+            assert isinstance(unpickled_content, SourceFileTraceabilityInfo), (
+                path_to_file,
+                unpickled_content,
+            )
+            return unpickled_content
+
+        reader = SourceFileTraceabilityCachingReader._get_reader(
+            path_to_file, project_config
+        )
+        traceability_info: SourceFileTraceabilityInfo = reader.read_from_file(
+            path_to_file
+        )
+        PickleCache.save_to_cache(
+            traceability_info, path_to_file, project_config, "source_file"
+        )
+
+        return traceability_info
+
+    @staticmethod
+    def _get_reader(
+        path_to_file: str, project_config: ProjectConfig
+    ) -> Union[
+        SourceFileTraceabilityReader,
+        SourceFileTraceabilityReader_Python,
+        SourceFileTraceabilityReader_C,
+    ]:
+        if project_config.is_activated_source_file_language_parsers():
+            if path_to_file.endswith(".py"):
+                return SourceFileTraceabilityReader_Python()
+            if path_to_file.endswith(".c"):
+                return SourceFileTraceabilityReader_C()
+        return SourceFileTraceabilityReader()

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/grammar.py

@@ -7,7 +7,7 @@ Part[noskipws]:
   // The EmptyLine is needed in addition to the SingleLineString because
   // otherwise textX's get_location() ignores the whitespaces.
   // TODO: Maybe there is a trick to disable that and only use SingleLineString.
-  EmptyLine | RangeMarker | LineMarker | SingleLineString
+  EmptyLine | RangeMarker | LineMarker | FunctionRangeMarker | SingleLineString
 ;
 
 EmptyLine[noskipws]:
@@ -31,6 +31,11 @@ RangeMarker[noskipws]:
   )
 ;
 
+FunctionRangeMarker[noskipws]:
+  /^.*?@relation/
+  "(" (reqs_objs += Req[', ']) ', scope=file)' '\n'?
+;
+
 LineMarker[noskipws]:
   // It is a hard-won result: it is important that the "@sdoc" is within the
   // regex. Putting it next to the regex as "@sdoc" does not work.

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/marker_parser.py

@@ -1,5 +1,5 @@
 import re
-from typing import List, Union
+from typing import List, Optional, Union
 
 from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
     FunctionRangeMarker,
@@ -23,6 +23,7 @@ class MarkerParser:
         line_end: int,
         comment_line_start: int,
         comment_column_start: int,
+        entity_name: Optional[str] = None,
     ) -> List[Union[FunctionRangeMarker, RangeMarker, LineMarker]]:
         markers: List[Union[FunctionRangeMarker, RangeMarker, LineMarker]] = []
         for input_line_idx_, input_line_ in enumerate(
@@ -63,6 +64,12 @@ class MarkerParser:
                 function_marker.ng_range_line_end = line_end
                 function_marker.ng_marker_line = current_line
                 function_marker.ng_marker_column = first_requirement_column
+                if marker_type == "file":
+                    function_marker.set_description("the whole file")
+                elif marker_type == "function":
+                    function_marker.set_description(f"function {entity_name}")
+                elif marker_type == "class":
+                    function_marker.set_description(f"class {entity_name}")
                 markers.append(function_marker)
             elif marker_type in ("range_start", "range_end"):
                 start_or_end = marker_type == "range_start"

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/models/function_range_marker.py

@@ -1,10 +1,17 @@
 # mypy: disable-error-code="no-untyped-def,type-arg"
+from enum import Enum
 from typing import List, Optional
 
 from strictdoc.backend.sdoc_source_code.models.requirement_marker import Req
 from strictdoc.helpers.auto_described import auto_described
 
 
+class RangeMarkerType(Enum):
+    FUNCTION = "function"
+    CLASS = "class"
+    FILE = "file"
+
+
 @auto_described
 class FunctionRangeMarker:
     def __init__(self, parent, reqs_objs: List[Req]):
@@ -33,6 +40,8 @@ class FunctionRangeMarker:
 
         self.ng_is_nodoc = "nosdoc" in self.reqs
 
+        self._description: Optional[str] = None
+
     def is_range_marker(self) -> bool:
         return True
 
@@ -45,6 +54,13 @@ class FunctionRangeMarker:
     def is_end(self) -> bool:
         return False
 
+    def get_description(self) -> Optional[str]:
+        return self._description
+
+    def set_description(self, description: str) -> None:
+        assert isinstance(description, str)
+        self._description = description
+
 
 @auto_described
 class ForwardFunctionRangeMarker(FunctionRangeMarker):

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/models/range_marker.py

@@ -58,6 +58,9 @@ class RangeMarker:
     def is_line_marker(self) -> bool:
         return False
 
+    def get_description(self) -> Optional[str]:
+        return "range"
+
 
 @auto_described
 class LineMarker:
@@ -88,6 +91,9 @@ class LineMarker:
     def is_line_marker(self) -> bool:
         return True
 
+    def get_description(self) -> Optional[str]:
+        return "line"
+
 
 @auto_described
 class ForwardRangeMarker:
@@ -116,3 +122,6 @@ class ForwardRangeMarker:
 
     def is_line_marker(self) -> bool:
         return False
+
+    def get_description(self) -> Optional[str]:
+        return "range"

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/reader.py

@@ -8,6 +8,9 @@ from textx import get_location, metamodel_from_str
 
 from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
 from strictdoc.backend.sdoc_source_code.grammar import SOURCE_FILE_GRAMMAR
+from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
+    FunctionRangeMarker,
+)
 from strictdoc.backend.sdoc_source_code.models.range_marker import (
     LineMarker,
     RangeMarker,
@@ -206,22 +209,49 @@ def line_marker_processor(line_marker: LineMarker, parse_context: ParseContext):
         markers.append(line_marker)
 
 
+def function_range_marker_processor(
+    function_range_marker: FunctionRangeMarker, parse_context: ParseContext
+):
+    location = get_location(function_range_marker)
+    line = location["line"]
+    column = location["col"]
+
+    if (
+        len(parse_context.marker_stack) > 0
+        and parse_context.marker_stack[-1].ng_is_nodoc
+    ):
+        # This marker is within a "nosdoc" block, so we ignore it.
+        return
+
+    parse_context.markers.append(function_range_marker)
+    function_range_marker.ng_source_line_begin = 1
+    function_range_marker.ng_range_line_begin = 1
+    function_range_marker.ng_range_line_end = parse_context.lines_total
+    function_range_marker.ng_marker_line = line
+    function_range_marker.ng_marker_column = column
+
+    for req in function_range_marker.reqs:
+        markers = parse_context.map_reqs_to_markers.setdefault(req, [])
+        markers.append(function_range_marker)
+
+
 class SourceFileTraceabilityReader:
     SOURCE_FILE_MODELS = [
-        Req,
+        FunctionRangeMarker,
         LineMarker,
+        Req,
         SourceFileTraceabilityInfo,
         RangeMarker,
     ]
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.meta_model = metamodel_from_str(
             SOURCE_FILE_GRAMMAR,
             classes=SourceFileTraceabilityReader.SOURCE_FILE_MODELS,
             use_regexp_group=True,
         )
 
-    def read(self, input_string, file_path=None):
+    def read(self, input_string, file_path=None) -> SourceFileTraceabilityInfo:
         # TODO: This might be possible to handle directly in the textx grammar.
         # AttributeError: 'str' object has no attribute '_tx_parser'
         file_size = len(input_string)
@@ -241,8 +271,12 @@ class SourceFileTraceabilityReader:
         parse_line_marker_processor = partial(
             line_marker_processor, parse_context=parse_context
         )
+        parse_function_range_marker_processor = partial(
+            function_range_marker_processor, parse_context=parse_context
+        )
 
         obj_processors = {
+            "FunctionRangeMarker": parse_function_range_marker_processor,
             "LineMarker": parse_line_marker_processor,
             "RangeMarker": parse_range_marker_processor,
             "Req": parse_req_processor,
@@ -271,7 +305,7 @@ class SourceFileTraceabilityReader:
         drop_textx_meta(source_file_traceability_info)
         return source_file_traceability_info
 
-    def read_from_file(self, file_path):
+    def read_from_file(self, file_path) -> SourceFileTraceabilityInfo:
         try:
             with open(file_path, encoding="utf-8") as file:
                 sdoc_content = file.read()

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/reader_c.py

@@ -1,10 +1,10 @@
 # mypy: disable-error-code="no-redef,no-untyped-call,no-untyped-def,type-arg,var-annotated"
 import sys
 import traceback
-from typing import List, Union
+from typing import List, Optional, Union
 
 import tree_sitter_c
-from tree_sitter import Language, Parser
+from tree_sitter import Language, Node, Parser
 
 from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
 from strictdoc.backend.sdoc_source_code.marker_parser import MarkerParser
@@ -31,7 +31,9 @@ from strictdoc.helpers.string import get_lines_count
 
 
 class SourceFileTraceabilityReader_C:
-    def read(self, input_buffer: bytes, file_path=None):
+    def read(
+        self, input_buffer: bytes, file_path=None
+    ) -> SourceFileTraceabilityInfo:
         assert isinstance(input_buffer, bytes)
 
         file_size = len(input_buffer)
@@ -55,7 +57,36 @@ class SourceFileTraceabilityReader_C:
 
         nodes = traverse_tree(tree)
         for node_ in nodes:
-            if node_.type == "function_definition":
+            if node_.type == "translation_unit":
+                if (
+                    len(node_.children) > 0
+                    and node_.children[0].type == "comment"
+                    and (comment_node := node_.children[0])
+                ):
+                    if comment_node.text is not None:
+                        comment_text = comment_node.text.decode("utf-8")
+                        markers = MarkerParser.parse(
+                            comment_text,
+                            node_.start_point[0] + 1,
+                            # It is important that +1 is not present here because
+                            # currently StrictDoc does not display the last empty line (\n is 10).
+                            node_.end_point[0]
+                            if input_buffer[-1] == 10
+                            else node_.end_point[0] + 1,
+                            node_.start_point[0] + 1,
+                            node_.start_point[1] + 1,
+                        )
+                        for marker_ in markers:
+                            if isinstance(marker_, FunctionRangeMarker) and (
+                                function_range_marker_ := marker_
+                            ):
+                                function_range_marker_processor(
+                                    function_range_marker_, parse_context
+                                )
+                                traceability_info.markers.append(
+                                    function_range_marker_
+                                )
+            elif node_.type == "function_definition":
                 function_name: str = ""
 
                 for child_ in node_.children:
@@ -66,6 +97,7 @@ class SourceFileTraceabilityReader_C:
                         function_name = child_.children[0].text.decode("utf8")
                 assert function_name is not None, "Function name"
 
+                function_comment_node: Optional[Node] = None
                 function_comment_text = None
                 if (
                     node_.prev_sibling is not None
@@ -87,6 +119,7 @@ class SourceFileTraceabilityReader_C:
                         function_last_line,
                         function_comment_node.start_point[0] + 1,
                         function_comment_node.start_point[1] + 1,
+                        entity_name=function_name,
                     )
                     for marker_ in markers:
                         if isinstance(marker_, FunctionRangeMarker) and (
@@ -102,10 +135,13 @@ class SourceFileTraceabilityReader_C:
                                 function_range_marker_
                             )
 
+                # The function range includes the top comment if it exists.
                 new_function = Function(
                     parent=None,
                     name=function_name,
-                    line_begin=node_.range.start_point[0] + 1,
+                    line_begin=function_comment_node.start_point[0] + 1
+                    if function_comment_node is not None
+                    else node_.range.start_point[0] + 1,
                     line_end=node_.range.end_point[0] + 1,
                     parts=[],
                 )

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/backend/sdoc_source_code/reader_python.py

@@ -1,7 +1,7 @@
 # mypy: disable-error-code="no-redef,no-untyped-call,no-untyped-def,type-arg,var-annotated"
 import sys
 import traceback
-from typing import List, Optional, Union
+from typing import List, Optional, Sequence, Union
 
 import tree_sitter_python
 from tree_sitter import Language, Node, Parser
@@ -31,7 +31,9 @@ from strictdoc.helpers.string import get_lines_count
 
 
 class SourceFileTraceabilityReader_Python:
-    def read(self, input_buffer: bytes, file_path=None):
+    def read(
+        self, input_buffer: bytes, file_path=None
+    ) -> SourceFileTraceabilityInfo:
         assert isinstance(input_buffer, bytes)
 
         file_size = len(input_buffer)
@@ -119,25 +121,9 @@ class SourceFileTraceabilityReader_Python:
 
                 assert function_name is not None, "Function name"
 
-                parent_class_name: Optional[str] = None
-                if (function_parent_node := node_.parent) is not None and (
-                    class_node_or_node := function_parent_node.parent
-                ) is not None:
-                    if (
-                        class_node_or_node.type == "class_definition"
-                        and len(class_node_or_node.children) > 1
-                    ):
-                        second_node_or_none = class_node_or_node.children[1]
-                        if (
-                            second_node_or_none.type == "identifier"
-                            and second_node_or_none.text is not None
-                        ):
-                            parent_class_name = second_node_or_none.text.decode(
-                                "utf8"
-                            )
-
-                if parent_class_name is not None:
-                    function_name = parent_class_name + "." + function_name
+                parent_names = self.get_node_ns(node_)
+                if parent_names:
+                    function_name = f"{'.'.join(parent_names)}.{function_name}"
 
                 block_comment = None
                 if (
@@ -168,6 +154,7 @@ class SourceFileTraceabilityReader_Python:
                                 node_.end_point[0] + 1,
                                 string_content.start_point[0] + 1,
                                 string_content.start_point[1] + 1,
+                                function_name,
                             )
                             for marker_ in markers:
                                 if isinstance(
@@ -223,6 +210,7 @@ class SourceFileTraceabilityReader_Python:
                     node_.end_point[0] + 1,
                     node_.start_point[0] + 1,
                     node_.start_point[1] + 1,
+                    None,
                 )
                 for marker_ in markers:
                     if isinstance(marker_, RangeMarker) and (
@@ -271,3 +259,31 @@ class SourceFileTraceabilityReader_Python:
             # TODO: when --debug is provided
             # traceback.print_exc()  # noqa: ERA001
             sys.exit(1)
+
+    @staticmethod
+    def get_node_ns(node: Node) -> Sequence[str]:
+        """Walk up the tree and find parent classes"""
+        parent_scopes = []
+        cursor: Optional[Node] = node
+        while cursor:
+            if (block_node := cursor.parent) is not None and (
+                class_node_or_node := block_node.parent
+            ) is not None:
+                cursor = class_node_or_node
+                if (
+                    class_node_or_node.type == "class_definition"
+                    and len(class_node_or_node.children) > 1
+                ):
+                    second_node_or_none = class_node_or_node.children[1]
+                    if (
+                        second_node_or_none.type == "identifier"
+                        and second_node_or_none.text is not None
+                    ):
+                        parent_class_name = second_node_or_none.text.decode(
+                            "utf8"
+                        )
+                        parent_scopes.append(parent_class_name)
+            else:
+                cursor = None
+        parent_scopes.reverse()
+        return parent_scopes

{strictdoc-0.1.0 → strictdoc-0.2.0}/strictdoc/core/document_finder.py

@@ -54,7 +54,7 @@ class DocumentFinder:
     @staticmethod
     def _process_worker_parse_document(
         document_triple: Tuple[Union[Folder, File], File, str],
-        path_to_output_root: str,
+        project_config: ProjectConfig,
     ) -> Tuple[File, str, Union[SDocDocument, DocumentGrammar]]:
         _, doc_file, file_tree_mount_folder = document_triple
         doc_full_path = doc_file.get_full_path()
@@ -64,12 +64,16 @@ class DocumentFinder:
         ):
             document_or_grammar: Union[SDocDocument, DocumentGrammar]
             if doc_full_path.endswith(".sdoc"):
-                sdoc_reader: SDReader = SDReader(path_to_output_root)
-                document_or_grammar = sdoc_reader.read_from_file(doc_full_path)
+                sdoc_reader: SDReader = SDReader()
+                document_or_grammar = sdoc_reader.read_from_file(
+                    doc_full_path, project_config
+                )
                 assert isinstance(document_or_grammar, SDocDocument)
             elif doc_full_path.endswith(".sgra"):
-                sgra_reader = SDocGrammarReader(path_to_output_root)
-                document_or_grammar = sgra_reader.read_from_file(doc_full_path)
+                sgra_reader = SDocGrammarReader()
+                document_or_grammar = sgra_reader.read_from_file(
+                    doc_full_path, project_config
+                )
                 assert isinstance(document_or_grammar, DocumentGrammar)
             else:
                 raise NotImplementedError
@@ -99,7 +103,7 @@ class DocumentFinder:
 
         process_document_binding = partial(
             DocumentFinder._process_worker_parse_document,
-            path_to_output_root=project_config.output_dir,
+            project_config=project_config,
         )
 
         found_documents = parallelizer.run_parallel(