[issue-406] fix xml specific problems, update parse/write_anything

Signed-off-by: Armin Tänzer <armin.taenzer@tngtech.com>

Author: armintaenzertng

src/parser/jsonlikedict/package_parser.py

@@ -60,8 +60,15 @@ def parse_package(self, package_dict: Dict) -> Package:
         external_refs: List[ExternalPackageRef] = parse_field_or_log_error(logger, package_dict.get("externalRefs"),
                                                                            self.parse_external_refs)
 
-        files_analyzed: Optional[bool] = parse_field_or_log_error(logger, package_dict.get("filesAnalyzed"),
+        files_analyzed: Optional[Union[bool, str]] = parse_field_or_log_error(logger, package_dict.get("filesAnalyzed"),
                                                                   lambda x: x, True)
+
+        if isinstance(files_analyzed, str): # XML does not support boolean typed values
+            if files_analyzed.lower() == "true":
+                files_analyzed = True
+            elif files_analyzed.lower() == "false":
+                files_analyzed = False
+
         homepage: Optional[str] = package_dict.get("homepage")
         license_comments: Optional[str] = package_dict.get("licenseComments")
         license_concluded = parse_field_or_log_error(

src/parser/jsonlikedict/snippet_parser.py

@@ -41,9 +41,13 @@ def parse_snippet(self, snippet_dict: Dict) -> Snippet:
         spdx_id: Optional[str] = snippet_dict.get("SPDXID")
         file_spdx_id: Optional[str] = snippet_dict.get("snippetFromFile")
         name: Optional[str] = snippet_dict.get("name")
+        
         ranges: Dict = parse_field_or_log_error(logger, snippet_dict.get("ranges", []), self.parse_ranges, default={})
-        byte_range: Tuple[int, int] = ranges.get(RangeType.BYTE)
-        line_range: Optional[Tuple[int, int]] = ranges.get(RangeType.LINE)
+        byte_range: Optional[Tuple[Union[int, str], Union[int, str]]] = ranges.get(RangeType.BYTE)
+        line_range: Optional[Tuple[Union[int, str], Union[int, str]]] = ranges.get(RangeType.LINE)
+        byte_range = self.convert_range_from_str(byte_range)
+        line_range = self.convert_range_from_str(line_range)
+
         attribution_texts: List[str] = snippet_dict.get("attributionTexts", [])
         comment: Optional[str] = snippet_dict.get("comment")
         copyright_text: Optional[str] = snippet_dict.get("copyrightText")
@@ -114,3 +118,15 @@ def validate_pointer_and_get_type(pointer: Dict) -> RangeType:
         if "offset" not in pointer and "lineNumber" not in pointer:
             raise ValueError('Couldn\'t determine type of pointer: neither "offset" nor "lineNumber" provided as key.')
         return RangeType.BYTE if "offset" in pointer else RangeType.LINE
+
+    @staticmethod
+    def convert_range_from_str(_range: Tuple[Union[int, str], Union[int, str]]) -> Tuple[Union[int, str], Union[int, str]]:
+        # XML does not support integers, so we have to convert from string (if possible)
+        if not _range:
+            return _range
+
+        if isinstance(_range[0], str) and _range[0].isdigit():
+            _range = int(_range[0]), _range[1]
+        if isinstance(_range[1], str) and _range[1].isdigit():
+            _range = _range[0], int(_range[1])
+        return _range

src/parser/parse_anything.py

@@ -9,7 +9,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from src.formats import file_name_to_format, FileFormat
-from src.parser.json.json_parser import JsonParser
+from src.parser.json import json_parser
+from src.parser.xml import xml_parser
+from src.parser.yaml import yaml_parser
 
 
 def parse_file(file_name: str):
@@ -19,8 +21,8 @@ def parse_file(file_name: str):
     elif input_format == FileFormat.TAG_VALUE:
         raise NotImplementedError("Currently, the tag-value parser is not implemented")
     elif input_format == FileFormat.JSON:
-        return JsonParser().parse(file_name)
+        return json_parser.parse_from_file(file_name)
     elif input_format == FileFormat.XML:
-        raise NotImplementedError("Currently, the xml parser is not implemented")
+        return xml_parser.parse_from_file(file_name)
     elif input_format == FileFormat.YAML:
-        raise NotImplementedError("Currently, the yaml parser is not implemented")
+        return yaml_parser.parse_from_file(file_name)

src/parser/xml/xml_parser.py

@@ -13,6 +13,7 @@
 import xmltodict
 
 from src.model.document import Document
+from src.parser.error import SPDXParsingError
 from src.parser.jsonlikedict.json_like_dict_parser import JsonLikeDictParser
 
 
@@ -40,14 +41,18 @@
     "ranges",
     "licenseInfoInSnippets",
     "packageVerificationCodeExcludedFiles",
+    "attributionTexts"
     ]
 
 
 def parse_from_file(file_name: str) -> Document:
     with open(file_name) as file:
         parsed_xml: Dict = xmltodict.parse(file.read(), encoding="utf-8")
 
-    input_doc_as_dict: Dict = _fix_list_like_fields(parsed_xml)
+    input_doc_as_dict: Dict = _fix_list_like_fields(parsed_xml).get("Document")
+
+    if not input_doc_as_dict:
+        raise SPDXParsingError(['Did not find the XML top level tag "Document".'])
 
     return JsonLikeDictParser().parse(input_doc_as_dict)
 

src/writer/write_anything.py

@@ -12,16 +12,18 @@
 from src.model.document import Document
 from src.writer.json import json_writer
 from src.writer.tagvalue import tagvalue_writer
+from src.writer.xml import xml_writer
+from src.writer.yaml import yaml_writer
 
 
 def write_file(document: Document, file_name: str, validate: bool = True):
     output_format = file_name_to_format(file_name)
     if output_format == FileFormat.JSON:
-        json_writer.write_document(document, file_name, validate)
+        json_writer.write_document(document, file_name, validate=False)
     elif output_format == FileFormat.YAML:
-        raise NotImplementedError("Currently, the yaml writer is not implemented")
+        yaml_writer.write_document_to_file(document, file_name, validate=False)
     elif output_format == FileFormat.XML:
-        raise NotImplementedError("Currently, the xml writer is not implemented")
+        xml_writer.write_document_to_file(document, file_name, validate=False)
     elif output_format == FileFormat.TAG_VALUE:
         tagvalue_writer.write_document_to_file(document, file_name)
     elif output_format == FileFormat.RDF_XML:

src/writer/xml/xml_writer.py

@@ -18,7 +18,7 @@
 from src.validation.validation_message import ValidationMessage
 
 
-def write_document(document: Document, file_name: str, validate: bool = True, converter: DocumentConverter = None):
+def write_document_to_file(document: Document, file_name: str, validate: bool = True, converter: DocumentConverter = None):
     """
     Serializes the provided document to XML and writes it to a file with the provided name. Unless validate is set
     to False, validates the document before serialization. Unless a DocumentConverter instance is provided,
@@ -31,6 +31,6 @@ def write_document(document: Document, file_name: str, validate: bool = True, co
             raise ValueError(f"Document is not valid. The following errors were detected: {validation_messages}")
     if converter is None:
         converter = DocumentConverter()
-    document_dict = converter.convert(document)
+    document_dict = {"Document": converter.convert(document)}
     with open(file_name, "w") as out:
         xmltodict.unparse(document_dict, out, encoding="utf-8", pretty=True)