h

Author: BrennanHCSC

file_processing/file.py

@@ -37,6 +37,7 @@ class File:
         ".txt": processors.TextFileProcessor,
         ".pdf": processors.PdfFileProcessor,
         ".docx": processors.DocxFileProcessor,
+        ".h": processors.HFileProcessor,
         ".go": processors.GoFileProcessor,
         ".msg": processors.MsgFileProcessor,
         ".pptx": processors.PptxFileProcessor,

file_processing/processors/__init__.py

@@ -17,6 +17,7 @@
 from .txt_processor import TextFileProcessor
 from .pdf_processor import PdfFileProcessor
 from .docx_processor import DocxFileProcessor
+from .h_processor import HFileProcessor
 from .msg_processor import MsgFileProcessor
 from .png_processor import PngFileProcessor
 from .xlsx_processor import XlsxFileProcessor

file_processing/processors/h_processor.py

@@ -0,0 +1,75 @@
+import chardet
+import re
+from file_processing.errors import FileProcessingFailedError
+from file_processing.file_processor_strategy import FileProcessorStrategy
+
+class HFileProcessor(FileProcessorStrategy):
+    """
+    Processor for handling C/C++ header files (.h), extracting metadata and content.
+
+    Attributes:
+        metadata (dict): Contains metadata such as:
+            'text' (str): Full file content as string.
+            'encoding' (str): Detected file encoding.
+            'num_lines' (int): Total number of lines.
+            'num_includes' (int): Count of preprocessor #include statements.
+            'num_macros' (int): Count of #define statements.
+            'num_structs' (int): Count of struct definitions.
+            'num_classes' (int): Count of class definitions (common in C++ headers).
+            'num_comments' (int): Count of single-line and multi-line comments.
+    """
+
+    def __init__(self, file_path: str, open_file: bool = True) -> None:
+        super().__init__(file_path, open_file)
+        self.metadata = {'message': 'File was not opened'} if not open_file else {}
+
+    def process(self) -> None:
+        if not self.open_file:
+            return
+        try:
+            raw_data = open(self.file_path, 'rb').read()
+            encoding = chardet.detect(raw_data)['encoding'] or 'utf-8'
+
+            with open(self.file_path, 'r', encoding=encoding, errors='replace') as f:
+                text = f.read()
+
+            num_lines = len(text.splitlines())
+
+            # Regex patterns:
+            include_pattern = re.compile(r'^\s*#\s*include\s+["<].*[">]', re.MULTILINE)
+            macro_pattern = re.compile(r'^\s*#\s*define\s+\w+', re.MULTILINE)
+            struct_pattern = re.compile(r'\bstruct\s+\w+', re.MULTILINE)
+            class_pattern = re.compile(r'\bclass\s+\w+', re.MULTILINE)
+            comment_pattern = re.compile(r'(//[^\n]*|/\*.*?\*/)', re.DOTALL)
+
+            num_includes = len(include_pattern.findall(text))
+            num_macros = len(macro_pattern.findall(text))
+            num_structs = len(struct_pattern.findall(text))
+            num_classes = len(class_pattern.findall(text))
+            num_comments = len(comment_pattern.findall(text))
+
+            self.metadata.update({
+                'text': text,
+                'encoding': encoding,
+                'num_lines': num_lines,
+                'num_includes': num_includes,
+                'num_macros': num_macros,
+                'num_structs': num_structs,
+                'num_classes': num_classes,
+                'num_comments': num_comments,
+            })
+
+        except Exception as e:
+            raise FileProcessingFailedError(
+                f"Error processing {self.file_path}: {e}"
+            )
+
+    def save(self, output_path: str = None) -> None:
+        try:
+            save_path = output_path or self.file_path
+            with open(save_path, 'w', encoding=self.metadata['encoding']) as f:
+                f.write(self.metadata['text'])
+        except Exception as e:
+            raise FileProcessingFailedError(
+                f"Error saving {self.file_path} to {save_path}: {e}"
+            )

tests/unit/test_h_processor.py

@@ -0,0 +1,52 @@
+import os
+import pytest
+from unittest.mock import patch
+from file_processing.file import File
+from file_processing.errors import FileProcessingFailedError
+from file_processing_test_data import get_test_files_path
+
+test_files_path = get_test_files_path()
+
+# (file_name, encoding, num_lines, num_includes, num_macros, num_structs, num_classes, num_comments)
+values = [
+    ('internal.h', 'ascii', 202, 5, 6, 4, 0, 23),
+    ('rtp_av1.h', 'ascii', 132, 2, 19, 0, 0, 13),
+    ('wglew.h', 'ascii', 958, 1, 356, 2, 0, 77),
+    ('wglext.h', 'ascii', 696, 1, 235, 1, 0, 27),
+]
+
+@pytest.mark.parametrize(
+    "file_name, encoding, num_lines, num_includes, num_macros, num_structs, num_classes, num_comments",
+    values
+)
+def test_h_metadata_extraction(file_name, encoding, num_lines, num_includes,
+                               num_macros, num_structs, num_classes, num_comments):
+    """Tests .h file processing metadata extraction."""
+    h_file_path = test_files_path / file_name
+    h_file = File(str(h_file_path))
+
+    metadata = h_file.processor.metadata
+    assert metadata['encoding'] == encoding
+    assert metadata['num_lines'] == num_lines
+    assert metadata['num_includes'] == num_includes
+    assert metadata['num_macros'] == num_macros
+    assert metadata['num_structs'] == num_structs
+    assert metadata['num_classes'] == num_classes
+    assert metadata['num_comments'] == num_comments
+
+@pytest.mark.parametrize("file_name", [entry[0] for entry in values])
+def test_h_invalid_save_location(file_name):
+    """Tests that saving to an invalid location raises an error."""
+    h_file_path = test_files_path / file_name
+    h_file = File(str(h_file_path))
+    invalid_save_path = '/non_existent_folder/' + file_name
+    with pytest.raises(FileProcessingFailedError):
+        h_file.save(invalid_save_path)
+
+@pytest.mark.parametrize("file_name", [entry[0] for entry in values])
+def test_h_processor_open_file_false(file_name):
+    """Tests that the file is not opened when open_file=False."""
+    h_file_path = test_files_path / file_name
+    with patch("builtins.open") as mock_open:
+        File(str(h_file_path), open_file=False)
+        mock_open.assert_not_called()