[issue-305, refactor] json_parser

Signed-off-by: Meret Behrens <meret.behrens@tngtech.com>
spdx · meretp · Dec 28, 2022 · Nov 25, 2022 · Dec 14, 2022 · Dec 14, 2022
commit 080d8482aba5952141c17ab7abc272243095205f
diff --git a/src/parser/json/json_parser.py b/src/parser/json/json_parser.py
@@ -9,21 +9,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import json
-from json import JSONDecodeError
-from typing import List
 
-from src.model.annotation import Annotation
-from src.model.document import Document, CreationInfo
-from src.model.extracted_licensing_info import ExtractedLicensingInfo
-from src.model.file import File
-from src.model.package import Package
-from src.model.relationship import Relationship
-from src.model.snippet import Snippet
+from src.model.document import Document
+from src.parser.error import SPDXParsingError
 from src.parser.json.annotation_parser import AnnotationParser
 from src.parser.json.creation_info_parser import CreationInfoParser
-from src.parser.error import SPDXParsingError
 from src.parser.json.dict_parsing_functions import raise_parsing_error_if_logger_has_messages, \
-    construct_or_raise_parsing_error, parse_field_or_log_error
+    construct_or_raise_parsing_error
 from src.parser.json.extracted_licensing_info_parser import ExtractedLicensingInfoParser
 from src.parser.json.file_parser import FileParser
 from src.parser.logger import Logger
@@ -53,46 +45,31 @@ def __init__(self):
         self.annotation_parser = AnnotationParser()
 
     def parse(self, filename: str) -> Document:
-        try:
-            with open(filename) as file:
-                input_doc_as_dict = json.load(file)
-        except FileNotFoundError:
-            self.logger.append(f"File {filename} not found.")
-            raise SPDXParsingError(self.logger.get_messages())
-        except JSONDecodeError:
-            self.logger.append(f"File {filename} is not a valid JSON file.")
-            raise SPDXParsingError(self.logger.get_messages())
 
-        creation_info: CreationInfo = parse_field_or_log_error(logger=self.logger, field=input_doc_as_dict,
-                                                               parsing_method=self.creation_info_parser.parse_creation_info)
+        with open(filename) as file:
+            input_doc_as_dict = json.load(file)
 
-            packages: List[Package] = parse_field_or_log_error(logger=self.logger, field=input_doc_as_dict.get("packages"),
-                                                           parsing_method=self.package_parser.parse_packages,
-                                                           optional=True)
+        fields_to_parse = [("creation_info", input_doc_as_dict, self.creation_info_parser.parse_creation_info, False),
+                           ("packages", input_doc_as_dict.get("packages"), self.package_parser.parse_packages, True),
+                           ("files", input_doc_as_dict.get("files"), self.file_parser.parse_files, True),
+                           ("annotations", input_doc_as_dict, self.annotation_parser.parse_all_annotations, True),
+                           ("snippets", input_doc_as_dict.get("snippets"), self.snippet_parser.parse_snippets, True),
+                           ("relationships", input_doc_as_dict, self.relationship_parser.parse_all_relationships, True),
+                           ("extracted_licensing_info", input_doc_as_dict.get("hasExtractedLicensingInfos"),
+                            self.extracted_licensing_info_parser.parse_extracted_licensing_infos, True)]
 
-        files: List[File] = parse_field_or_log_error(logger=self.logger, field=input_doc_as_dict.get("files"),
-                                                     parsing_method=self.file_parser.parse_files, optional=True)
+        parsed_fields = {}
 
-        annotations: List[Annotation] = parse_field_or_log_error(logger=self.logger, field=input_doc_as_dict,
-                                                                 parsing_method=self.annotation_parser.parse_all_annotations,
-                                                                 optional=True)
-        snippets: List[Snippet] = parse_field_or_log_error(logger=self.logger, field=input_doc_as_dict.get("snippets"),
-                                                           parsing_method=self.snippet_parser.parse_snippets,
-                                                           optional=True)
-        relationships: List[Relationship] = parse_field_or_log_error(logger=self.logger, field=input_doc_as_dict,
-                                                                     parsing_method=self.relationship_parser.parse_all_relationships,
-                                                                     optional=True)
-        extracted_licensing_info: List[ExtractedLicensingInfo] = parse_field_or_log_error(logger=self.logger,
-                                                                                          field=input_doc_as_dict.get("hasExtractedLicensingInfos"),
-                                                                                          parsing_method=self.extracted_licensing_info_parser.parse_extracted_licensing_infos,
-                                                                                          optional=True)
+        for argument_name, field, parsing_method, optional in fields_to_parse:
+            if optional and not field:
+                continue
+            try:
+                parsed_fields[argument_name] = parsing_method(field)
+            except SPDXParsingError as err:
+                self.logger.extend(err.get_messages())
 
         raise_parsing_error_if_logger_has_messages(self.logger)
 
-        document = construct_or_raise_parsing_error(Document, dict(creation_info=creation_info, packages=packages,
-                                                                   files=files,
-                                                                   annotations=annotations,
-                                                                   snippets=snippets, relationships=relationships,
-                                                                   extracted_licensing_info=extracted_licensing_info))
+        document = construct_or_raise_parsing_error(Document, parsed_fields)
 
         return document
diff --git a/tests/parser/test_json_parser.py b/tests/parser/test_json_parser.py
@@ -17,12 +17,12 @@
 from src.parser.json.json_parser import JsonParser
 
 def test_json_parser_file_not_found():
-    with pytest.raises(SPDXParsingError) as err:
+    with pytest.raises(FileNotFoundError) as err:
         wrong_file_path = os.path.join(os.path.dirname(__file__), 'test.json')
         _ = JsonParser().parse(wrong_file_path)
 
-    assert err.typename == "SPDXParsingError"
-    assert err.value.messages[0] == f"File {wrong_file_path} not found."
+    assert err.type == FileNotFoundError
+    assert err.value.args[1] == "No such file or directory"
 
 
 def test_json_parser_with_2_3_example():