[Issue 359] Add Json writer for new data model

src/datetime_conversions.py

@@ -10,8 +10,6 @@
 #  limitations under the License.
 from datetime import datetime
 
-from src.parser.error import SPDXParsingError
-
 
 def datetime_from_str(date_str: str) -> datetime:
     if not isinstance(date_str, str):

src/document_utils.py

@@ -0,0 +1,20 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from typing import List
+
+from src.model.document import Document
+
+
+def get_contained_spdx_element_ids(document: Document) -> List[str]:
+    element_ids = [file.spdx_id for file in document.files]
+    element_ids.extend([package.spdx_id for package in document.packages])
+    element_ids.extend([snippet.spdx_id for snippet in document.snippets])
+    return element_ids

src/jsonschema/annotation_converter.py

@@ -0,0 +1,37 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from typing import Type, Any
+
+from src.datetime_conversions import datetime_to_iso_string
+from src.jsonschema.annotation_properties import AnnotationProperty
+from src.jsonschema.converter import TypedConverter
+from src.jsonschema.json_property import JsonProperty
+from src.model.annotation import Annotation
+from src.model.document import Document
+
+
+class AnnotationConverter(TypedConverter[Annotation]):
+    def _get_property_value(self, annotation: Annotation, annotation_property: AnnotationProperty,
+                            document: Document = None) -> Any:
+        if annotation_property == AnnotationProperty.ANNOTATION_DATE:
+            return datetime_to_iso_string(annotation.annotation_date)
+        elif annotation_property == AnnotationProperty.ANNOTATION_TYPE:
+            return annotation.annotation_type.name
+        elif annotation_property == AnnotationProperty.ANNOTATOR:
+            return annotation.annotator.to_serialized_string()
+        elif annotation_property == AnnotationProperty.COMMENT:
+            return annotation.annotation_comment
+
+    def get_json_type(self) -> Type[JsonProperty]:
+        return AnnotationProperty
+
+    def get_data_model_type(self) -> Type[Annotation]:
+        return Annotation

src/jsonschema/annotation_properties.py

@@ -0,0 +1,20 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from enum import auto
+
+from src.jsonschema.json_property import JsonProperty
+
+
+class AnnotationProperty(JsonProperty):
+    ANNOTATION_DATE = auto()
+    ANNOTATION_TYPE = auto()
+    ANNOTATOR = auto()
+    COMMENT = auto()

src/jsonschema/checksum_converter.py

@@ -0,0 +1,40 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from typing import Type
+
+from src.jsonschema.checksum_properties import ChecksumProperty
+from src.jsonschema.converter import TypedConverter
+from src.jsonschema.json_property import JsonProperty
+from src.model.checksum import Checksum, ChecksumAlgorithm
+from src.model.document import Document
+
+
+class ChecksumConverter(TypedConverter[Checksum]):
+
+    def get_data_model_type(self) -> Type[Checksum]:
+        return Checksum
+
+    def get_json_type(self) -> Type[JsonProperty]:
+        return ChecksumProperty
+
+    def _get_property_value(self, checksum: Checksum, checksum_property: ChecksumProperty,
+                            _document: Document = None) -> str:
+        if checksum_property == ChecksumProperty.ALGORITHM:
+            return algorithm_to_json_string(checksum.algorithm)
+        elif checksum_property == ChecksumProperty.CHECKSUM_VALUE:
+            return checksum.value
+
+
+def algorithm_to_json_string(algorithm: ChecksumAlgorithm) -> str:
+    name_with_dash: str = algorithm.name.replace("_", "-")
+    if "BLAKE2B" in name_with_dash:
+        return name_with_dash.replace("BLAKE2B", "BLAKE2b")
+    return name_with_dash

src/jsonschema/checksum_properties.py

@@ -0,0 +1,18 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from enum import auto
+
+from src.jsonschema.json_property import JsonProperty
+
+
+class ChecksumProperty(JsonProperty):
+    ALGORITHM = auto()
+    CHECKSUM_VALUE = auto()

src/jsonschema/converter.py

@@ -0,0 +1,73 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from abc import ABC, abstractmethod
+from typing import Any, Type, Dict, TypeVar, Generic
+
+from src.jsonschema.json_property import JsonProperty
+from src.model.document import Document
+from src.writer.casing_tools import snake_case_to_camel_case
+
+MISSING_IMPLEMENTATION_MESSAGE = "Must be implemented"
+
+T = TypeVar("T")
+
+
+class TypedConverter(ABC, Generic[T]):
+    """
+    Base class for all converters between an instance of the tools-python data model and the corresponding dictionary
+    representation, following the json schema. The generic type T is the type according to the data model.
+    Each converter has several methods:
+    - get_json_type and get_data_model_type: return the data model type and the corresponding JsonProperty subclass.
+    These methods are abstract in the base class and need to be implemented in subclasses.
+    - json_property_name: converts an enum value of a JsonProperty subclass to the corresponding property name in the
+    json schema. The default implementation simply converts from snake case to camel case. Can be overridden in case
+    of exceptions like "SPDXID".
+    - convert: converts an instance of type T (one of the data model types) to a dictionary representation. In some
+    cases, the full document is required (see below). The logic should be generic for all types.
+    - requires_full_document: indicates whether the full document is required for conversion. Returns False by
+    default, can be overridden as needed for specific types.
+    - _get_property_value: Retrieves the value of a specific json property from the data model instance. In some
+    cases, the full document is required.
+    """
+
+    @abstractmethod
+    def _get_property_value(self, instance: T, json_property: JsonProperty, document: Document = None) -> Any:
+        raise NotImplementedError(MISSING_IMPLEMENTATION_MESSAGE)
+
+    @abstractmethod
+    def get_json_type(self) -> Type[JsonProperty]:
+        raise NotImplementedError(MISSING_IMPLEMENTATION_MESSAGE)
+
+    @abstractmethod
+    def get_data_model_type(self) -> Type[T]:
+        raise NotImplementedError(MISSING_IMPLEMENTATION_MESSAGE)
+
+    def json_property_name(self, json_property: JsonProperty) -> str:
+        return snake_case_to_camel_case(json_property.name)
+
+    def requires_full_document(self) -> bool:
+        return False
+
+    def convert(self, instance: T, document: Document = None) -> Dict:
+        if not isinstance(instance, self.get_data_model_type()):
+            raise TypeError(
+                f"Converter of type {self.__class__} can only convert objects of type "
+                f"{self.get_data_model_type()}. Received {type(instance)} instead.")
+        if self.requires_full_document() and not document:
+            raise ValueError(f"Converter of type {self.__class__} requires the full document")
+
+        result = {}
+        for property_name in self.get_json_type():
+            property_value = self._get_property_value(instance, property_name, document)
+            if property_value is None:
+                continue
+            result[self.json_property_name(property_name)] = property_value
+        return result

src/jsonschema/creation_info_converter.py

@@ -0,0 +1,37 @@
+#  Copyright (c) 2022 spdx contributors
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from typing import Type, Any
+
+from src.datetime_conversions import datetime_to_iso_string
+from src.jsonschema.converter import TypedConverter
+from src.jsonschema.creation_info_properties import CreationInfoProperty
+from src.jsonschema.json_property import JsonProperty
+from src.jsonschema.optional_utils import apply_if_present
+from src.model.document import CreationInfo, Document
+
+
+class CreationInfoConverter(TypedConverter[CreationInfo]):
+    def get_data_model_type(self) -> Type[CreationInfo]:
+        return CreationInfo
+
+    def get_json_type(self) -> Type[JsonProperty]:
+        return CreationInfoProperty
+
+    def _get_property_value(self, creation_info: CreationInfo, creation_info_property: CreationInfoProperty,
+                            _document: Document = None) -> Any:
+        if creation_info_property == CreationInfoProperty.CREATED:
+            return datetime_to_iso_string(creation_info.created)
+        elif creation_info_property == CreationInfoProperty.CREATORS:
+            return [creator.to_serialized_string() for creator in creation_info.creators] or None
+        elif creation_info_property == CreationInfoProperty.LICENSE_LIST_VERSION:
+            return apply_if_present(str, creation_info.license_list_version)
+        elif creation_info_property == CreationInfoProperty.COMMENT:
+            return creation_info.creator_comment

src/jsonschema/creation_info_properties.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2022 spdx contributors
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from enum import auto
+
+from src.jsonschema.json_property import JsonProperty
+
+
+class CreationInfoProperty(JsonProperty):
+    CREATED = auto()
+    CREATORS = auto()
+    LICENSE_LIST_VERSION = auto()
+    COMMENT = auto()