strictdoc 0.0.60__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strictdoc
-Version: 0.0.60
+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/
@@ -33,6 +33,9 @@ Requires-Dist: selenium
 Requires-Dist: spdx-tools
 Requires-Dist: textx==3.*,>=3.0.0
 Requires-Dist: toml
+Requires-Dist: tree-sitter
+Requires-Dist: tree-sitter-c
+Requires-Dist: tree-sitter-python
 Requires-Dist: uvicorn[standard]>=0.14.0
 Requires-Dist: webdriver-manager
 Requires-Dist: websockets

{strictdoc-0.0.60 → strictdoc-0.2.0}/pyproject.toml

@@ -56,6 +56,11 @@ dependencies = [
     # Parsing and rendering RST.
     "docutils >= 0.16, == 0.*",
 
+    # Tree Sitter is used for language/AST-aware parsing of Python, C and other files.
+    "tree-sitter",
+    "tree-sitter-c",
+    "tree-sitter-python",
+
     # Requirements-to-source traceability. Colored syntax for source files.
     "pygments >= 2.10.0, == 2.*",
 

{strictdoc-0.0.60 → strictdoc-0.2.0}/strictdoc/__init__.py

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

{strictdoc-0.0.60 → strictdoc-0.2.0}/strictdoc/backend/sdoc/error_handling.py

@@ -1,4 +1,6 @@
 # mypy: disable-error-code="attr-defined,no-untyped-call,no-untyped-def,union-attr"
+from typing import Optional
+
 from textx import TextXSyntaxError
 
 from strictdoc.backend.sdoc.models.document import SDocDocument
@@ -25,7 +27,13 @@ def get_textx_syntax_error_message(exception: TextXSyntaxError):
 
 class StrictDocSemanticError(Exception):
     def __init__(
-        self, title, hint, example, line=None, col=None, filename=None
+        self,
+        title: str,
+        hint: Optional[str],
+        example: Optional[str],
+        line: Optional[int] = None,
+        col: Optional[int] = None,
+        filename: Optional[str] = None,
     ):
         super().__init__(title, hint, line, col, filename)
         self.title = title

{strictdoc-0.0.60 → strictdoc-0.2.0}/strictdoc/backend/sdoc/grammar/type_system.py

@@ -47,6 +47,8 @@ FileEntry[noskipws]:
   ('  FORMAT: ' g_file_format = FileEntryFormat '\n')?
    '  VALUE: ' g_file_path = /.*$/ '\n'
   ('  LINE_RANGE: ' g_line_range = /.*$/ '\n')?
+  ('  FUNCTION: ' function = /.*$/ '\n')?
+  ('  CLASS: ' clazz = /.*$/ '\n')?
 ;
 
 FileEntryFormat[noskipws]:

{strictdoc-0.0.60 → 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.0.60 → strictdoc-0.2.0}/strictdoc/backend/sdoc/models/type_system.py

@@ -56,6 +56,8 @@ class FileEntry:
         g_file_format: Optional[str],
         g_file_path: str,
         g_line_range: Optional[str],
+        function: Optional[str],
+        clazz: Optional[str],
     ):
         self.parent = parent
 
@@ -85,6 +87,14 @@ class FileEntry:
                 int(range_components_str[1]),
             )
 
+        # textX parses an optional element as an empty string. We make it to None ourselves.
+        self.function: Optional[str] = (
+            function if function is not None and len(function) > 0 else None
+        )
+        self.clazz: Optional[str] = (
+            clazz if clazz is not None and len(clazz) > 0 else None
+        )
+
 
 class FileEntryFormat:
     SOURCECODE = "Sourcecode"

{strictdoc-0.0.60 → 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.0.60 → 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.0.60 → 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]:
@@ -18,21 +18,41 @@ RangeMarker[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.
   // TODO: It would be great to check this with the TextX developers.
+  (
   /^.*?@sdoc/
   (begin_or_end = "[/" | begin_or_end = "[")
   (reqs_objs += Req[', ']) ']' '\n'?
+  )
+  |
+  (
+  /^.*?@relation/
+  '('
+  (reqs_objs += Req[', ']) ', scope=' scope=/(range_start|range_end)/ ')' '\n'?
+  )
+;
+
+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.
   // TODO: It would be great to check this with the TextX developers.
+  (
   /^.*?@sdoc/
   "(" (reqs_objs += Req[', ']) ')' '\n'?
+  )
+  |
+  (
+  /^.*?@relation/
+  "(" (reqs_objs += Req[', ']) ', scope=line)' '\n'?
+  )
 ;
 
 Req[noskipws]:
-  uid = /[A-Za-z][A-Za-z0-9\\-]+/
+  uid = /(?!scope=)[A-Za-z][A-Za-z0-9\\-]+/
 ;
 
 SingleLineString[noskipws]:

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

@@ -0,0 +1,94 @@
+import re
+from typing import List, Optional, Union
+
+from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
+    FunctionRangeMarker,
+)
+from strictdoc.backend.sdoc_source_code.models.range_marker import (
+    LineMarker,
+    RangeMarker,
+)
+from strictdoc.backend.sdoc_source_code.models.requirement_marker import Req
+
+REGEX_REQ = r"[A-Za-z][A-Za-z0-9\\-]+"
+# @relation(REQ-1, scope=function)
+REGEX_MARKER = rf"@relation\(({REGEX_REQ}(?:, {REGEX_REQ})*)\, scope=(file|class|function|line|range_start|range_end)\)"
+
+
+class MarkerParser:
+    @staticmethod
+    def parse(
+        input_string: str,
+        line_start: int,
+        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(
+            input_string.splitlines()
+        ):
+            match = re.search(REGEX_MARKER, input_line_)
+            if match is None:
+                continue
+
+            assert match.lastindex is not None
+            marker_type = match.group(match.lastindex)
+            req_list = match.group(1)
+
+            first_requirement_index = match.start(1)
+
+            current_line = comment_line_start + input_line_idx_
+            first_requirement_column = first_requirement_index + 1
+            if input_line_idx_ == 0:
+                first_requirement_column += comment_column_start - 1
+            requirements = []
+            for req_match in re.finditer(REGEX_REQ, req_list):
+                req_item = req_match.group(0)  # Matched REQ-XXX item
+                # Calculate actual position relative to the original string
+                start_index = (
+                    req_match.start()
+                )  # Offset by where group 1 starts
+                requirement = Req(None, req_item)
+                requirement.ng_source_line = current_line
+                requirement.ng_source_column = (
+                    first_requirement_column + start_index
+                )
+                requirements.append(requirement)
+
+            if marker_type in ("file", "class", "function"):
+                function_marker = FunctionRangeMarker(None, requirements)
+                function_marker.ng_source_line_begin = line_start
+                function_marker.ng_range_line_begin = line_start
+                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"
+                range_marker = RangeMarker(
+                    None, "[" if start_or_end else "[/", requirements
+                )
+                range_marker.ng_source_line_begin = line_start
+                range_marker.ng_source_column_begin = first_requirement_column
+                range_marker.ng_range_line_begin = line_start
+                range_marker.ng_range_line_end = line_end
+                range_marker.ng_is_language_parsed = True
+                markers.append(range_marker)
+            elif marker_type == "line":
+                line_marker = LineMarker(None, requirements)
+                line_marker.ng_source_line_begin = line_start
+                line_marker.ng_range_line_begin = line_start
+                line_marker.ng_range_line_end = line_end
+                markers.append(line_marker)
+            else:
+                continue
+
+        return markers

strictdoc-0.2.0/strictdoc/backend/sdoc_source_code/models/function.py

@@ -0,0 +1,20 @@
+from typing import Any, List
+
+from strictdoc.helpers.auto_described import auto_described
+
+
+@auto_described
+class Function:
+    def __init__(
+        self,
+        parent: Any,
+        name: str,
+        line_begin: int,
+        line_end: int,
+        parts: List[Any],
+    ):
+        self.parent = parent
+        self.name = name
+        self.parts: List[Any] = parts
+        self.line_begin = line_begin
+        self.line_end = line_end

strictdoc-0.2.0/strictdoc/backend/sdoc_source_code/models/function_range_marker.py

@@ -0,0 +1,68 @@
+# 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]):
+        assert isinstance(reqs_objs, list)
+        self.parent = parent
+        self.reqs_objs: List[Req] = reqs_objs
+        self.reqs: List[str] = list(map(lambda req: req.uid, reqs_objs))
+
+        # Line number of the marker in the source code.
+        self.ng_source_line_begin: Optional[int] = None
+        self.ng_source_column_begin: Optional[int] = None
+
+        # Line number of the marker range in the source code:
+        # TODO: Improve description.
+        # For Begin ranges:
+        #   ng_range_line_begin == ng_source_line_begin  # noqa: ERA001
+        #   ng_range_line_end == ng_source_line_begin of the End marker  # noqa: ERA001, E501
+        # For End ranges:
+        #   ng_range_line_begin == ng_range_line_begin of the Begin marker  # noqa: ERA001, E501
+        #   ng_range_line_end == ng_source_line_begin  # noqa: ERA001
+        self.ng_range_line_begin: Optional[int] = None
+        self.ng_range_line_end: Optional[int] = None
+
+        self.ng_marker_line: Optional[int] = None
+        self.ng_marker_column: Optional[int] = None
+
+        self.ng_is_nodoc = "nosdoc" in self.reqs
+
+        self._description: Optional[str] = None
+
+    def is_range_marker(self) -> bool:
+        return True
+
+    def is_line_marker(self) -> bool:
+        return False
+
+    def is_begin(self) -> bool:
+        return True
+
+    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):
+    def __init__(self, parent, reqs_objs: List[Req]):
+        super().__init__(parent, reqs_objs)

strictdoc-0.2.0/strictdoc/backend/sdoc_source_code/models/range_marker.py

@@ -0,0 +1,127 @@
+# mypy: disable-error-code="no-untyped-def,type-arg"
+from typing import Any, List, Optional
+
+from strictdoc.backend.sdoc_source_code.models.requirement_marker import Req
+from strictdoc.helpers.auto_described import auto_described
+
+
+@auto_described
+class RangeMarker:
+    def __init__(
+        self,
+        parent: Any,
+        begin_or_end: str,
+        reqs_objs: List[Req],
+        scope: str = "",
+    ):
+        assert isinstance(reqs_objs, list)
+        self.parent: Any = parent
+        assert len(begin_or_end) > 0 or scope is not None
+
+        self.begin_or_end: str
+        if len(begin_or_end) > 0:
+            self.begin_or_end = begin_or_end
+        else:
+            assert scope in ("range_start", "range_end")
+            self.begin_or_end = "[" if scope == "range_start" else "[/"
+
+        self.reqs_objs: List[Req] = reqs_objs
+        self.reqs: List[str] = list(map(lambda req: req.uid, reqs_objs))
+
+        # Line number of the marker in the source code.
+        self.ng_source_line_begin: Optional[int] = None
+        self.ng_source_column_begin: Optional[int] = None
+
+        # Line number of the marker range in the source code:
+        # TODO: Improve description.
+        # For Begin ranges:
+        #   ng_range_line_begin == ng_source_line_begin  # noqa: ERA001
+        #   ng_range_line_end == ng_source_line_begin of the End marker  # noqa: ERA001, E501
+        # For End ranges:
+        #   ng_range_line_begin == ng_range_line_begin of the Begin marker  # noqa: ERA001, E501
+        #   ng_range_line_end == ng_source_line_begin  # noqa: ERA001
+        self.ng_range_line_begin: Optional[int] = None
+        self.ng_range_line_end: Optional[int] = None
+
+        self.ng_is_nodoc = "nosdoc" in self.reqs
+        self.ng_is_language_parsed = False
+
+    def is_begin(self) -> bool:
+        return self.begin_or_end == "["
+
+    def is_end(self) -> bool:
+        return self.begin_or_end == "[/"
+
+    def is_range_marker(self) -> bool:
+        return True
+
+    def is_line_marker(self) -> bool:
+        return False
+
+    def get_description(self) -> Optional[str]:
+        return "range"
+
+
+@auto_described
+class LineMarker:
+    def __init__(self, parent: Any, reqs_objs: List[Req]) -> None:
+        assert isinstance(reqs_objs, list)
+        self.parent = parent
+        self.reqs_objs = reqs_objs
+        self.reqs = list(map(lambda req: req.uid, reqs_objs))
+
+        # Line number of the marker in the source code.
+        self.ng_source_line_begin: Optional[int] = None
+        self.ng_source_column_begin: Optional[int] = None
+
+        self.ng_range_line_begin: Optional[int] = None
+        self.ng_range_line_end: Optional[int] = None
+
+        self.ng_is_nodoc = "nosdoc" in self.reqs
+
+    def is_begin(self) -> bool:
+        return True
+
+    def is_end(self) -> bool:
+        return False
+
+    def is_range_marker(self) -> bool:
+        return False
+
+    def is_line_marker(self) -> bool:
+        return True
+
+    def get_description(self) -> Optional[str]:
+        return "line"
+
+
+@auto_described
+class ForwardRangeMarker:
+    def __init__(self, start_or_end: bool, reqs_objs: List):
+        assert len(reqs_objs) > 0
+        self.start_or_end: bool = start_or_end
+
+        self.reqs_objs = reqs_objs
+
+        # Line number of the marker in the source code.
+        self.ng_source_line_begin: Optional[int] = None
+
+        self.ng_range_line_begin: Optional[int] = None
+        self.ng_range_line_end: Optional[int] = None
+
+        self.ng_is_nodoc = False
+
+    def is_begin(self) -> bool:
+        return self.start_or_end
+
+    def is_end(self) -> bool:
+        return not self.start_or_end
+
+    def is_range_marker(self) -> bool:
+        return True
+
+    def is_line_marker(self) -> bool:
+        return False
+
+    def get_description(self) -> Optional[str]:
+        return "range"