strictdoc 0.2.1__tar.gz → 0.3.0__tar.gz

{strictdoc-0.2.1 → strictdoc-0.3.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: strictdoc
-Version: 0.2.1
+Version: 0.3.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/
 Project-URL: Source, https://github.com/strictdoc-project/strictdoc
 Author-email: Stanislav Pankevich <s.pankevich@gmail.com>, Maryna Balioura <mettta@gmail.com>
+License: Apache-2.0
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/__init__.py

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

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc/models/document_config.py

@@ -5,7 +5,7 @@ from strictdoc.helpers.auto_described import auto_described
 
 
 @auto_described
-class DocumentConfig:  # pylint: disable=too-many-instance-attributes
+class DocumentConfig:
     @staticmethod
     def default_config(document) -> "DocumentConfig":
         return DocumentConfig(

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc/models/section.py

@@ -20,7 +20,7 @@ class SectionContext:
 
 
 @auto_described
-class SDocSection(SDocObject):  # pylint: disable=too-many-instance-attributes
+class SDocSection(SDocObject):
     def __init__(
         self,
         parent,

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/caching_reader.py

@@ -54,6 +54,6 @@ class SourceFileTraceabilityCachingReader:
         if project_config.is_activated_source_file_language_parsers():
             if path_to_file.endswith(".py"):
                 return SourceFileTraceabilityReader_Python()
-            if path_to_file.endswith(".c"):
+            if path_to_file.endswith(".c") or path_to_file.endswith(".h"):
                 return SourceFileTraceabilityReader_C()
         return SourceFileTraceabilityReader()

strictdoc-0.3.0/strictdoc/backend/sdoc_source_code/constants.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class FunctionAttribute(Enum):
+    STATIC = "static"
+    DECLARATION = "declaration"
+    DEFINITION = "definition"

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/grammar.py

@@ -1,6 +1,6 @@
 SOURCE_FILE_GRAMMAR = """
 SourceFileTraceabilityInfo[noskipws]:
-  parts += Part
+  g_parts += Part
 ;
 
 Part[noskipws]:
@@ -33,7 +33,7 @@ RangeMarker[noskipws]:
 
 FunctionRangeMarker[noskipws]:
   /^.*?@relation/
-  "(" (reqs_objs += Req[', ']) ', scope=file)' '\n'?
+  "(" (reqs_objs += Req[', ']) ', scope=' scope="file" ')' '\n'?
 ;
 
 LineMarker[noskipws]:

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/marker_parser.py

@@ -58,7 +58,9 @@ class MarkerParser:
                 requirements.append(requirement)
 
             if marker_type in ("file", "class", "function"):
-                function_marker = FunctionRangeMarker(None, requirements)
+                function_marker = FunctionRangeMarker(
+                    None, requirements, scope=marker_type
+                )
                 function_marker.ng_source_line_begin = line_start
                 function_marker.ng_range_line_begin = line_start
                 function_marker.ng_range_line_end = line_end

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

@@ -0,0 +1,42 @@
+from typing import Any, List, Set
+
+from strictdoc.backend.sdoc_source_code.constants import FunctionAttribute
+from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
+    FunctionRangeMarker,
+)
+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,
+        child_functions: List[Any],
+        markers: List[FunctionRangeMarker],
+        attributes: Set[FunctionAttribute],
+    ):
+        assert parent is not None
+        self.parent = parent
+        self.name = name
+        # Child functions are supported in programming languages that can nest
+        # functions, for example, Python.
+        self.child_functions: List[Function] = child_functions
+        self.markers: List[FunctionRangeMarker] = markers
+        self.line_begin = line_begin
+        self.line_end = line_end
+        self.attributes: Set[FunctionAttribute] = attributes
+
+    def is_declaration(self) -> bool:
+        return FunctionAttribute.DECLARATION in self.attributes
+
+    def is_definition(self) -> bool:
+        return FunctionAttribute.DEFINITION in self.attributes
+
+    def is_public(self) -> bool:
+        if FunctionAttribute.STATIC in self.attributes:
+            return False
+        return True

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/models/function_range_marker.py

@@ -14,12 +14,15 @@ class RangeMarkerType(Enum):
 
 @auto_described
 class FunctionRangeMarker:
-    def __init__(self, parent, reqs_objs: List[Req]):
+    def __init__(self, parent, reqs_objs: List[Req], scope: str):
         assert isinstance(reqs_objs, list)
+        assert isinstance(scope, str), scope
         self.parent = parent
         self.reqs_objs: List[Req] = reqs_objs
         self.reqs: List[str] = list(map(lambda req: req.uid, reqs_objs))
 
+        self.scope: RangeMarkerType = RangeMarkerType(scope)
+
         # 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
@@ -64,5 +67,5 @@ class FunctionRangeMarker:
 
 @auto_described
 class ForwardFunctionRangeMarker(FunctionRangeMarker):
-    def __init__(self, parent, reqs_objs: List[Req]):
-        super().__init__(parent, reqs_objs)
+    def __init__(self, parent, reqs_objs: List[Req], scope: str):
+        super().__init__(parent, reqs_objs, scope)

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/models/range_marker.py

@@ -45,7 +45,7 @@ class RangeMarker:
         self.ng_range_line_end: Optional[int] = None
 
         self.ng_is_nodoc = "nosdoc" in self.reqs
-        self.ng_new_relation_keyword = False
+        self.ng_new_relation_keyword = scope is not None and len(scope) > 0
 
     def is_begin(self) -> bool:
         return self.begin_or_end == "["

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/models/source_file_info.py

@@ -1,5 +1,5 @@
 # mypy: disable-error-code="no-untyped-def,type-arg,var-annotated"
-from typing import List, Union
+from typing import Dict, List, Union
 
 from strictdoc.backend.sdoc_source_code.models.function import Function
 from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
@@ -15,7 +15,7 @@ from strictdoc.helpers.auto_described import auto_described
 
 @auto_described
 class SourceFileTraceabilityInfo:
-    def __init__(self, parts: List):
+    def __init__(self, g_parts: List):
         """
         At the init time, only the backward RangeMarkers are available from
         a source file. At runtime, the ForwardRangeMarkers are mixed in
@@ -23,7 +23,7 @@ class SourceFileTraceabilityInfo:
         is a union.
         """
 
-        self.parts: List = parts
+        self.g_parts: List = g_parts
         self.functions: List[Function] = []
 
         """
@@ -34,6 +34,9 @@ class SourceFileTraceabilityInfo:
         """
         self.ng_map_reqs_to_markers = {}
 
+        self.ng_map_names_to_markers: Dict[str, List] = {}
+        self.ng_map_names_to_definition_functions: Dict[str, Function] = {}
+
         self.ng_lines_total = 0
         self.ng_lines_covered = 0
         self._coverage: float = 0

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/reader_c.py

@@ -7,6 +7,7 @@ import tree_sitter_c
 from tree_sitter import Language, Node, Parser
 
 from strictdoc.backend.sdoc.error_handling import StrictDocSemanticError
+from strictdoc.backend.sdoc_source_code.constants import FunctionAttribute
 from strictdoc.backend.sdoc_source_code.marker_parser import MarkerParser
 from strictdoc.backend.sdoc_source_code.models.function import Function
 from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
@@ -26,7 +27,11 @@ from strictdoc.backend.sdoc_source_code.processors.general_language_marker_proce
     range_marker_processor,
     source_file_traceability_info_processor,
 )
-from strictdoc.backend.sdoc_source_code.tree_sitter_helpers import traverse_tree
+from strictdoc.backend.sdoc_source_code.tree_sitter_helpers import (
+    traverse_tree,
+    ts_find_child_node_by_type,
+    ts_find_child_nodes_by_type,
+)
 from strictdoc.helpers.string import get_lines_count
 
 
@@ -86,6 +91,83 @@ class SourceFileTraceabilityReader_C:
                                 traceability_info.markers.append(
                                     function_range_marker_
                                 )
+            elif node_.type == "declaration":
+                function_declarator_node = ts_find_child_node_by_type(
+                    node_, "function_declarator"
+                )
+                if function_declarator_node is None:
+                    continue
+
+                function_identifier_node = ts_find_child_node_by_type(
+                    function_declarator_node, "identifier"
+                )
+                if function_identifier_node is None:
+                    continue
+
+                if function_identifier_node.text is None:
+                    continue
+
+                function_name: str = function_identifier_node.text.decode(
+                    "utf8"
+                )
+                assert function_name is not None, function_name
+
+                function_attributes = {FunctionAttribute.DECLARATION}
+                for specifier_node_ in ts_find_child_nodes_by_type(
+                    node_, "storage_class_specifier"
+                ):
+                    if specifier_node_.text == b"static":
+                        function_attributes.add(FunctionAttribute.STATIC)
+
+                function_markers: List[FunctionRangeMarker] = []
+                function_comment_node: Optional[Node] = None
+                function_comment_text = None
+                if (
+                    node_.prev_sibling is not None
+                    and node_.prev_sibling.type == "comment"
+                ):
+                    function_comment_node = node_.prev_sibling
+                    assert function_comment_node.text is not None
+                    function_comment_text = function_comment_node.text.decode(
+                        "utf8"
+                    )
+
+                    function_last_line = node_.end_point[0] + 1
+
+                    markers = MarkerParser.parse(
+                        function_comment_text,
+                        function_comment_node.start_point[0] + 1,
+                        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 (
+                            function_range_marker_ := marker_
+                        ):
+                            function_range_marker_processor(
+                                function_range_marker_, parse_context
+                            )
+                            traceability_info.markers.append(
+                                function_range_marker_
+                            )
+                            function_markers.append(marker_)
+
+                # The function range includes the top comment if it exists.
+                new_function = Function(
+                    parent=traceability_info,
+                    name=function_name,
+                    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,
+                    child_functions=[],
+                    markers=function_markers,
+                    attributes=function_attributes,
+                )
+                traceability_info.functions.append(new_function)
+
             elif node_.type == "function_definition":
                 function_name: str = ""
 
@@ -97,6 +179,7 @@ class SourceFileTraceabilityReader_C:
                         function_name = child_.children[0].text.decode("utf8")
                 assert function_name is not None, "Function name"
 
+                function_markers: List[FunctionRangeMarker] = []
                 function_comment_node: Optional[Node] = None
                 function_comment_text = None
                 if (
@@ -111,9 +194,7 @@ class SourceFileTraceabilityReader_C:
 
                     function_last_line = node_.end_point[0] + 1
 
-                    markers: List[
-                        Union[FunctionRangeMarker, RangeMarker, LineMarker]
-                    ] = MarkerParser.parse(
+                    markers = MarkerParser.parse(
                         function_comment_text,
                         function_comment_node.start_point[0] + 1,
                         function_last_line,
@@ -131,21 +212,28 @@ class SourceFileTraceabilityReader_C:
                             traceability_info.markers.append(
                                 function_range_marker_
                             )
-                            traceability_info.parts.append(
-                                function_range_marker_
-                            )
+                            function_markers.append(marker_)
 
                 # The function range includes the top comment if it exists.
                 new_function = Function(
-                    parent=None,
+                    parent=traceability_info,
                     name=function_name,
                     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=[],
+                    child_functions=[],
+                    markers=function_markers,
+                    attributes={FunctionAttribute.DEFINITION},
                 )
                 traceability_info.functions.append(new_function)
+                if len(function_markers) > 0:
+                    traceability_info.ng_map_names_to_markers[function_name] = (
+                        function_markers
+                    )
+                    traceability_info.ng_map_names_to_definition_functions[
+                        function_name
+                    ] = new_function
             elif node_.type == "comment":
                 if node_.text is None:
                     raise NotImplementedError("Comment without a text")
@@ -166,12 +254,10 @@ class SourceFileTraceabilityReader_C:
                         range_marker_ := marker_
                     ):
                         range_marker_processor(range_marker_, parse_context)
-                        traceability_info.parts.append(range_marker_)
                     elif isinstance(marker_, LineMarker) and (
                         line_marker_ := marker_
                     ):
                         line_marker_processor(line_marker_, parse_context)
-                        traceability_info.parts.append(line_marker_)
                     else:
                         continue
             else:

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/reader_python.py

@@ -62,11 +62,13 @@ class SourceFileTraceabilityReader_Python:
         for node_ in nodes:
             if node_.type == "module":
                 function = Function(
-                    parent=None,
+                    parent=traceability_info,
                     name="module",
                     line_begin=node_.start_point[0] + 1,
                     line_end=node_.end_point[0] + 1,
-                    parts=[],
+                    child_functions=[],
+                    markers=[],
+                    attributes=set(),
                 )
                 functions_stack.append(function)
                 map_function_to_node[function] = node_
@@ -183,17 +185,20 @@ class SourceFileTraceabilityReader_Python:
                     functions_stack = functions_stack[:1]
 
                 new_function = Function(
-                    parent=None,
+                    parent=traceability_info,
                     name=function_name,
                     line_begin=node_.range.start_point[0] + 1,
                     line_end=node_.range.end_point[0] + 1,
-                    parts=[],
+                    child_functions=[],
+                    # Python functions do not need to track markers.
+                    markers=[],
+                    attributes=set(),
                 )
                 map_function_to_node[new_function] = node_
 
                 parent_function = functions_stack[-1]
 
-                parent_function.parts.append(new_function)
+                parent_function.child_functions.append(new_function)
                 functions_stack.append(new_function)
                 traceability_info.functions.append(new_function)
             elif node_.type == "comment":
@@ -231,8 +236,6 @@ class SourceFileTraceabilityReader_Python:
             or functions_stack[0].name == "translation_unit"
         )
 
-        traceability_info.parts = functions_stack[0].parts
-
         source_file_traceability_info_processor(
             traceability_info, parse_context
         )

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/backend/sdoc_source_code/tree_sitter_helpers.py

@@ -1,4 +1,4 @@
-from typing import Generator
+from typing import Generator, Optional
 
 from tree_sitter import Node, Tree
 
@@ -16,3 +16,18 @@ def traverse_tree(tree: Tree) -> Generator[Node, None, None]:
             visited_children = False
         elif not cursor.goto_parent():
             break
+
+
+def ts_find_child_node_by_type(node: Node, node_type: str) -> Optional[Node]:
+    for child_ in node.children:
+        if child_.type == node_type:
+            return child_
+    return None
+
+
+def ts_find_child_nodes_by_type(
+    node: Node, node_type: str
+) -> Generator[Node, None, None]:
+    for child_ in node.children:
+        if child_.type == node_type:
+            yield child_

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/cli/cli_arg_parser.py

@@ -109,7 +109,7 @@ class ServerCommandConfig:
 
 
 @auto_described
-class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
+class ExportCommandConfig:
     def __init__(
         self,
         input_paths,

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/core/file_traceability_index.py

@@ -3,6 +3,8 @@ from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 from strictdoc.backend.sdoc.models.node import SDocNode
 from strictdoc.backend.sdoc.models.reference import FileReference, Reference
+from strictdoc.backend.sdoc_source_code.constants import FunctionAttribute
+from strictdoc.backend.sdoc_source_code.models.function import Function
 from strictdoc.backend.sdoc_source_code.models.function_range_marker import (
     ForwardFunctionRangeMarker,
     FunctionRangeMarker,
@@ -45,6 +47,11 @@ class FileTraceabilityIndex:
             str, Dict[str, List[str]]
         ] = {}
 
+        # This is only public non-static functions from languages like C.
+        self.map_all_function_names_to_definition_functions: Dict[
+            str, Function
+        ] = {}
+
         # "file.py" -> (
         #   general_requirements: [SDocNode],  # noqa: ERA001
         #   range_requirements: [SDocNode]  # noqa: ERA001
@@ -52,7 +59,13 @@ class FileTraceabilityIndex:
         self.source_file_reqs_cache = {}
 
     def has_source_file_reqs(self, source_file_rel_path: str) -> bool:
-        return self.map_paths_to_reqs.get(source_file_rel_path) is not None
+        path_reqs = self.map_paths_to_reqs.get(source_file_rel_path)
+        if path_reqs is not None and len(path_reqs) > 0:
+            return True
+        file_trace_info = self.map_paths_to_source_file_traceability_info[
+            source_file_rel_path
+        ]
+        return len(file_trace_info.markers) > 0
 
     def get_requirement_file_links(
         self, requirement: SDocNode
@@ -153,7 +166,7 @@ class FileTraceabilityIndex:
         )
         return source_file_tr_info
 
-    def validate(self):
+    def validate_and_resolve(self, traceability_index):
         for requirement_uid, file_links in self.map_reqs_uids_to_paths.items():
             for file_link in file_links:
                 source_file_traceability_info: Optional[
@@ -204,6 +217,89 @@ class FileTraceabilityIndex:
                 source_file_info.markers.append(start_marker)
                 source_file_info.markers.append(end_marker)
 
+        """
+        Resolve definitions to declarations (only applicable for C and C++).
+        """
+
+        reversed_trace_info = {
+            value: key
+            for key, value in self.map_paths_to_source_file_traceability_info.items()
+        }
+
+        for (
+            traceability_info_
+        ) in self.map_paths_to_source_file_traceability_info.values():
+            for function_ in traceability_info_.functions:
+                if (
+                    FunctionAttribute.DECLARATION in function_.attributes
+                    and function_.name
+                    in self.map_all_function_names_to_definition_functions
+                ):
+                    definition_function: Optional[Function]
+                    if not function_.is_public():
+                        definition_function = traceability_info_.ng_map_names_to_definition_functions.get(
+                            function_.name
+                        )
+                    else:
+                        definition_function = (
+                            self.map_all_function_names_to_definition_functions[
+                                function_.name
+                            ]
+                        )
+                    if definition_function is None:
+                        continue
+                    definition_function_trace_info: SourceFileTraceabilityInfo = definition_function.parent
+
+                    for marker_ in function_.markers:
+                        function_marker = ForwardFunctionRangeMarker(
+                            parent=None,
+                            reqs_objs=marker_.reqs_objs,
+                            scope="function",
+                        )
+                        function_marker.ng_source_line_begin = (
+                            definition_function.line_begin
+                        )
+                        function_marker.ng_source_column_begin = 1
+                        function_marker.ng_range_line_begin = (
+                            definition_function.line_begin
+                        )
+                        function_marker.ng_range_line_end = (
+                            definition_function.line_end
+                        )
+                        function_marker.ng_marker_line = (
+                            definition_function.line_begin
+                        )
+                        function_marker.ng_marker_column = 1
+                        function_marker.set_description(
+                            f"function {function_.name}"
+                        )
+
+                        for req_uid_ in marker_.reqs:
+                            markers = definition_function_trace_info.ng_map_reqs_to_markers.setdefault(
+                                req_uid_, []
+                            )
+                            markers.append(function_marker)
+
+                            path_to_info = reversed_trace_info[
+                                definition_function_trace_info
+                            ]
+                            self.map_reqs_uids_to_paths.setdefault(
+                                req_uid_, OrderedSet()
+                            )
+                            self.map_reqs_uids_to_paths[req_uid_].add(
+                                path_to_info
+                            )
+
+                            node = traceability_index.get_node_by_uid(req_uid_)
+                            self.map_paths_to_reqs.setdefault(
+                                path_to_info, OrderedSet()
+                            )
+                            self.map_paths_to_reqs[path_to_info].add(node)
+
+                        definition_function_trace_info.markers.append(
+                            function_marker
+                        )
+
         for (
             traceability_info_
         ) in self.map_paths_to_source_file_traceability_info.values():
@@ -336,6 +432,15 @@ class FileTraceabilityIndex:
         for function_ in traceability_info.functions:
             marker_type: RangeMarkerType
 
+            if FunctionAttribute.DEFINITION in function_.attributes:
+                assert (
+                    function_.name
+                    not in self.map_all_function_names_to_definition_functions
+                )
+                self.map_all_function_names_to_definition_functions[
+                    function_.name
+                ] = function_
+
             if (
                 source_file_rel_path
                 in self.map_file_function_names_to_reqs_uids
@@ -365,7 +470,7 @@ class FileTraceabilityIndex:
                 reqs.append(req)
 
             function_marker = ForwardFunctionRangeMarker(
-                parent=None, reqs_objs=reqs
+                parent=None, reqs_objs=reqs, scope=marker_type.value
             )
             function_marker.ng_source_line_begin = function_.line_begin
             function_marker.ng_source_column_begin = 1

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/core/file_tree.py

@@ -62,7 +62,7 @@ class File(FileOrFolderEntry):
         return os.path.basename(os.path.dirname(self.root_path))
 
 
-class Folder(FileOrFolderEntry):  # pylint: disable=too-many-instance-attributes
+class Folder(FileOrFolderEntry):
     def __init__(self, root_path: str, rel_path: str, level):
         assert os.path.isdir(root_path)
         assert os.path.isabs(root_path)

{strictdoc-0.2.1 → strictdoc-0.3.0}/strictdoc/core/finders/source_files_finder.py

@@ -12,7 +12,7 @@ from strictdoc.helpers.auto_described import auto_described
 
 class SourceFileType(Enum):
     PYTHON = [".py"]
-    C = [".c"]
+    C = [".h", ".c"]
     CPP = [".cpp", ".cc"]
     TEX = [".tex"]
     # Is there an idiomatic file extension for Jinja templates?
@@ -30,7 +30,7 @@ class SourceFileType(Enum):
     def create_from_path(cls, path_to_file: str) -> "SourceFileType":
         if path_to_file.endswith(".py"):
             return cls.PYTHON
-        if path_to_file.endswith(".c"):
+        if path_to_file.endswith(".h") or path_to_file.endswith(".c"):
             return cls.C
         for enum_value in SourceFileType.CPP.value:
             if path_to_file.endswith(enum_value):
@@ -64,7 +64,7 @@ class SourceFileType(Enum):
 
 
 @auto_described
-class SourceFile:  # pylint: disable=too-many-instance-attributes
+class SourceFile:
     def __init__(
         self,
         level,
@@ -147,12 +147,14 @@ class SourceFilesFinder:
 
         assert isinstance(project_config.output_dir, str)
 
+        exclude_paths = project_config.exclude_source_paths + ["**.DS_Store"]
+
         file_tree = FileFinder.find_files_with_extensions(
             root_path=doctree_root_abs_path,
             ignored_dirs=[project_config.output_dir],
             extensions=None,
             include_paths=project_config.include_source_paths,
-            exclude_paths=project_config.exclude_source_paths,
+            exclude_paths=exclude_paths,
         )
         root_level = doctree_root_abs_path.count(os.sep)