Merge pull request #218 from hc-sc-ocdo-bdpd/java

Java

Author: BrennanHCSC

file_processing/file.py

@@ -41,6 +41,7 @@ class File:
         ".xml": processors.XmlFileProcessor,
         ".png": processors.PngFileProcessor,
         ".xlsx": processors.XlsxFileProcessor,
+        ".java": processors.JavaFileProcessor,
         ".jpeg": processors.JpegFileProcessor,
         ".jpg": processors.JpegFileProcessor,
         ".json": processors.JsonFileProcessor,

file_processing/processors/__init__.py

@@ -40,3 +40,4 @@
 from .gguf_processor import GgufFileProcessor
 from .exe_processor import ExeFileProcessor
 from .whl_processor import WhlFileProcessor
+from .java_processor import JavaFileProcessor

file_processing/processors/java_processor.py

@@ -0,0 +1,88 @@
+import chardet
+from file_processing.errors import FileProcessingFailedError
+from file_processing.file_processor_strategy import FileProcessorStrategy
+
+class JavaFileProcessor(FileProcessorStrategy):
+    """
+    Processor for handling Java files (.java), extracting source code metadata and content.
+
+    Attributes:
+        metadata (dict): Contains extracted metadata such as 'text', 'encoding',
+                         'num_lines', 'num_characters', 'num_methods', and 'num_classes'.
+    """
+
+    def __init__(self, file_path: str, open_file: bool = True) -> None:
+        """
+        Initializes the JavaFileProcessor with the specified file path.
+
+        Args:
+            file_path (str): Path to the Java file to process.
+            open_file (bool): Indicates whether to open and process the file immediately.
+
+        Sets:
+            metadata (dict): Populated with 'message' if `open_file` is False.
+        """
+        super().__init__(file_path, open_file)
+        self.metadata = {'message': 'File was not opened'} if not open_file else {}
+
+    def process(self) -> None:
+        """
+        Extracts metadata from the Java source file if it is open and accessible.
+
+        Metadata extracted includes the source text, file encoding, number of lines,
+        number of characters, number of methods, and number of classes.
+
+        Raises:
+            FileProcessingFailedError: If an error occurs during Java file processing.
+        """
+        if not self.open_file:
+            return
+        try:
+            raw_data = open(self.file_path, 'rb').read()
+            encoding = chardet.detect(raw_data)['encoding']
+
+            with open(self.file_path, 'r', encoding=encoding) as f:
+                text = f.read()
+
+                num_lines = len(text.splitlines())
+                num_characters = len(text)
+
+                # Simple method/class counting using regex patterns
+                import re
+                method_pattern = re.compile(r'\b(public|private|protected|static|\s)+\s+\w+\s+\w+\s*\([^\)]*\)\s*\{', re.MULTILINE)
+                class_pattern = re.compile(r'\b(class|interface|enum)\s+\w+', re.MULTILINE)
+
+                num_methods = len(method_pattern.findall(text))
+                num_classes = len(class_pattern.findall(text))
+
+                self.metadata.update({
+                    'text': text,
+                    'encoding': encoding,
+                    'num_lines': num_lines,
+                    'num_characters': num_characters,
+                    'num_methods': num_methods,
+                    'num_classes': num_classes,
+                })
+        except Exception as e:
+            raise FileProcessingFailedError(
+                f"Error encountered while processing {self.file_path}: {e}"
+            )
+
+    def save(self, output_path: str = None) -> None:
+        """
+        Saves the processed Java file to the specified output path with current metadata.
+
+        Args:
+            output_path (str): Path to save the processed Java file. If None, overwrites the original file.
+
+        Raises:
+            FileProcessingFailedError: If an error occurs while saving the Java file.
+        """
+        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 encountered while saving file {self.file_path} to {save_path}: {e}"
+            )

tests/unit/test_java_processor.py

@@ -0,0 +1,48 @@
+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
+
+# Get the directory where test files are stored
+test_files_path = get_test_files_path()
+
+# Java test file metadata expectations (filename, text length, encoding, num_lines, num_methods, num_classes)
+values = [
+    ('DataTypes.java', 59831, 'ascii', 1409, 70, 17),
+    ('ExecutionJobVertex.java', 27219, 'ascii', 695, 24, 2),
+    ('TopicAdmin.java', 39062, 'ascii', 770, 25, 3),
+    ('Utils.java', 4721, 'ascii', 106, 7, 1),
+]
+
+@pytest.mark.parametrize(
+    "file_name, text_length, encoding, num_lines, num_methods, num_classes",
+    values
+)
+def test_java_metadata_extraction(file_name, text_length, encoding, num_lines, num_methods, num_classes):
+    """Tests Java file processing metadata extraction."""
+    java_file_path = test_files_path / file_name
+    java_file = File(java_file_path)
+
+    assert len(java_file.processor.metadata['text']) == text_length
+    assert java_file.processor.metadata['encoding'] == encoding
+    assert java_file.processor.metadata['num_lines'] == num_lines
+    assert java_file.processor.metadata['num_methods'] == num_methods
+    assert java_file.processor.metadata['num_classes'] == num_classes
+
+@pytest.mark.parametrize("file_name", [file_name for file_name, *_ in values])
+def test_java_invalid_save_location(file_name):
+    """Tests that saving to an invalid location raises an error."""
+    java_file = File(test_files_path / file_name)
+    invalid_save_path = '/non_existent_folder/' + file_name
+    with pytest.raises(FileProcessingFailedError):
+        java_file.save(invalid_save_path)
+
+@pytest.mark.parametrize("file_name", [file_name for file_name, *_ in values])
+def test_java_processor_open_file_false(file_name):
+    """Tests that the file is not opened when open_file=False."""
+    java_file_path = test_files_path / file_name
+    with patch("builtins.open") as mock_open:
+        File(java_file_path, open_file=False)
+        mock_open.assert_not_called()