spdx_tools.spdx3.bump_from_spdx2.relationship

  1# SPDX-FileCopyrightText: 2023 spdx contributors
  2#
  3# SPDX-License-Identifier: Apache-2.0
  4import logging
  5import sys
  6
  7from beartype.typing import Dict, List, Optional, Tuple, Union
  8
  9from spdx_tools.spdx3.bump_from_spdx2.message import print_missing_conversion
 10from spdx_tools.spdx3.model import LifecycleScopeType, Relationship, RelationshipCompleteness, RelationshipType
 11from spdx_tools.spdx3.model.software import (
 12    DependencyConditionalityType,
 13    SoftwareDependencyLinkType,
 14    SoftwareDependencyRelationship,
 15)
 16from spdx_tools.spdx3.payload import Payload
 17from spdx_tools.spdx.model.relationship import Relationship as Spdx2_Relationship
 18from spdx_tools.spdx.model.relationship import RelationshipType as Spdx2_RelationshipType
 19from spdx_tools.spdx.model.spdx_no_assertion import SpdxNoAssertion
 20from spdx_tools.spdx.model.spdx_none import SpdxNone
 21
 22# bump relationship type, map each relationship type to the corresponding class in 3.0,
 23# the relationship type, other arguments and if swapped
 24relationship_mapping: Dict[
 25    Spdx2_RelationshipType,
 26    Tuple[
 27        Union[Relationship, SoftwareDependencyRelationship],
 28        RelationshipType,
 29        Dict[str, Union[bool, LifecycleScopeType, SoftwareDependencyLinkType, DependencyConditionalityType]],
 30    ],
 31] = {
 32    Spdx2_RelationshipType.AMENDS: (Relationship, RelationshipType.AMENDS, {}),
 33    Spdx2_RelationshipType.ANCESTOR_OF: (Relationship, RelationshipType.ANCESTOR, {}),
 34    Spdx2_RelationshipType.BUILD_DEPENDENCY_OF: (
 35        SoftwareDependencyRelationship,
 36        RelationshipType.DEPENDS_ON,
 37        {
 38            "scope": LifecycleScopeType.BUILD,
 39            "linkage": SoftwareDependencyLinkType.TOOL,
 40        },
 41    ),
 42    Spdx2_RelationshipType.BUILD_TOOL_OF: (
 43        SoftwareDependencyRelationship,
 44        RelationshipType.DEPENDS_ON,
 45        {"scope": LifecycleScopeType.BUILD, "linkage": SoftwareDependencyLinkType.TOOL},
 46    ),
 47    Spdx2_RelationshipType.CONTAINED_BY: (Relationship, RelationshipType.CONTAINS, {"swap": True}),
 48    Spdx2_RelationshipType.CONTAINS: (
 49        Relationship,
 50        RelationshipType.CONTAINS,
 51        {},
 52    ),  # might be deleted in favor of depends on
 53    Spdx2_RelationshipType.COPY_OF: (Relationship, RelationshipType.COPY, {}),
 54    Spdx2_RelationshipType.DATA_FILE_OF: (None, None, {}),  # not defined, probably input/ output
 55    Spdx2_RelationshipType.DEPENDENCY_MANIFEST_OF: (
 56        SoftwareDependencyRelationship,
 57        RelationshipType.DEPENDS_ON,
 58        {},
 59    ),  # "expect purpose has been set to manifest"
 60    Spdx2_RelationshipType.DEPENDENCY_OF: (
 61        SoftwareDependencyRelationship,
 62        RelationshipType.DEPENDS_ON,
 63        {"swap": True},
 64    ),
 65    Spdx2_RelationshipType.DEPENDS_ON: (SoftwareDependencyRelationship, RelationshipType.DEPENDS_ON, {}),
 66    Spdx2_RelationshipType.DESCENDANT_OF: (Relationship, RelationshipType.ANCESTOR, {"swap": True}),
 67    Spdx2_RelationshipType.DESCRIBED_BY: (Relationship, RelationshipType.DESCRIBES, {"swap": True}),
 68    Spdx2_RelationshipType.DESCRIBES: (
 69        Relationship,
 70        RelationshipType.DESCRIBES,
 71        {},
 72    ),  # might be deleted in favor of root
 73    # property
 74    Spdx2_RelationshipType.DEV_DEPENDENCY_OF: (
 75        SoftwareDependencyRelationship,
 76        RelationshipType.DEPENDS_ON,
 77        {"scope": LifecycleScopeType.DEVELOPMENT},
 78    ),
 79    Spdx2_RelationshipType.DEV_TOOL_OF: (
 80        SoftwareDependencyRelationship,
 81        RelationshipType.DEPENDS_ON,
 82        {"scope": LifecycleScopeType.DEVELOPMENT, "linkage": SoftwareDependencyLinkType.TOOL},
 83    ),
 84    Spdx2_RelationshipType.DISTRIBUTION_ARTIFACT: (None, None, {}),  # not defined yet, purpose?
 85    Spdx2_RelationshipType.DOCUMENTATION_OF: (Relationship, RelationshipType.DOCUMENTATION, {}),
 86    Spdx2_RelationshipType.DYNAMIC_LINK: (
 87        SoftwareDependencyRelationship,
 88        RelationshipType.DEPENDS_ON,
 89        {"linkage": SoftwareDependencyLinkType.DYNAMIC},
 90    ),
 91    Spdx2_RelationshipType.EXAMPLE_OF: (Relationship, RelationshipType.EXAMPLE, {}),
 92    Spdx2_RelationshipType.EXPANDED_FROM_ARCHIVE: (Relationship, RelationshipType.EXPANDED_FROM_ARCHIVE, {}),
 93    Spdx2_RelationshipType.FILE_ADDED: (Relationship, RelationshipType.FILE_ADDED, {}),
 94    Spdx2_RelationshipType.FILE_DELETED: (Relationship, RelationshipType.FILE_DELETED, {}),
 95    Spdx2_RelationshipType.FILE_MODIFIED: (Relationship, RelationshipType.FILE_MODIFIED, {}),
 96    Spdx2_RelationshipType.GENERATED_FROM: (Relationship, RelationshipType.GENERATES, {"swap": True}),
 97    Spdx2_RelationshipType.GENERATES: (Relationship, RelationshipType.GENERATES, {}),
 98    Spdx2_RelationshipType.HAS_PREREQUISITE: (
 99        SoftwareDependencyRelationship,
100        RelationshipType.DEPENDS_ON,
101        {"conditionality": DependencyConditionalityType.PREREQUISITE},
102    ),
103    Spdx2_RelationshipType.METAFILE_OF: (Relationship, RelationshipType.METAFILE, {}),
104    Spdx2_RelationshipType.OPTIONAL_COMPONENT_OF: (None, None, {}),  # converted to depends on and purpose? not clear
105    Spdx2_RelationshipType.OPTIONAL_DEPENDENCY_OF: (
106        SoftwareDependencyRelationship,
107        RelationshipType.DEPENDS_ON,
108        {"conditionality": DependencyConditionalityType.OPTIONAL},
109    ),
110    Spdx2_RelationshipType.OTHER: (Relationship, RelationshipType.OTHER, {}),
111    Spdx2_RelationshipType.PACKAGE_OF: (SoftwareDependencyRelationship, RelationshipType.DEPENDS_ON, {}),
112    Spdx2_RelationshipType.PATCH_APPLIED: (Relationship, RelationshipType.PATCH, {"swap": True}),
113    Spdx2_RelationshipType.PATCH_FOR: (Relationship, RelationshipType.PATCH, {}),
114    Spdx2_RelationshipType.PREREQUISITE_FOR: (
115        SoftwareDependencyRelationship,
116        RelationshipType.DEPENDS_ON,
117        {"conditionality": DependencyConditionalityType.PREREQUISITE},
118    ),
119    Spdx2_RelationshipType.PROVIDED_DEPENDENCY_OF: (
120        SoftwareDependencyRelationship,
121        RelationshipType.DEPENDS_ON,
122        {"scope": LifecycleScopeType.BUILD, "conditionality": DependencyConditionalityType.PROVIDED},
123    ),
124    Spdx2_RelationshipType.RUNTIME_DEPENDENCY_OF: (
125        SoftwareDependencyRelationship,
126        RelationshipType.DEPENDS_ON,
127        {"scope": LifecycleScopeType.RUNTIME},
128    ),
129    Spdx2_RelationshipType.STATIC_LINK: (
130        SoftwareDependencyRelationship,
131        RelationshipType.DEPENDS_ON,
132        {"linkage": SoftwareDependencyLinkType.STATIC},
133    ),
134    Spdx2_RelationshipType.TEST_CASE_OF: (Relationship, RelationshipType.TEST_CASE, {}),
135    Spdx2_RelationshipType.TEST_DEPENDENCY_OF: (
136        SoftwareDependencyRelationship,
137        RelationshipType.DEPENDS_ON,
138        {"scope": LifecycleScopeType.TEST},
139    ),
140    Spdx2_RelationshipType.TEST_OF: (Relationship, RelationshipType.TEST, {}),
141    Spdx2_RelationshipType.TEST_TOOL_OF: (
142        SoftwareDependencyRelationship,
143        RelationshipType.DEPENDS_ON,
144        {"scope": LifecycleScopeType.TEST, "linkage": SoftwareDependencyLinkType.TOOL},
145    ),
146    Spdx2_RelationshipType.VARIANT_OF: (Relationship, RelationshipType.VARIANT, {}),
147    Spdx2_RelationshipType.REQUIREMENT_DESCRIPTION_FOR: (Relationship, RelationshipType.REQUIREMENT_FOR, {}),
148    Spdx2_RelationshipType.SPECIFICATION_FOR: (Relationship, RelationshipType.SPECIFICATION_FOR, {}),
149}
150
151
152def bump_relationships(
153    spdx2_relationships: List[Spdx2_Relationship],
154    payload: Payload,
155    document_namespace: str,
156):
157    generated_relationships: Dict[Tuple[str, str], List[Relationship]] = {}
158    for counter, spdx2_relationship in enumerate(spdx2_relationships):
159        relationship = bump_relationship(spdx2_relationship, document_namespace, counter)
160        if relationship:
161            generated_relationships.setdefault(
162                (relationship.from_element, relationship.relationship_type.name), []
163            ).append(relationship)
164
165    for relationships in generated_relationships.values():
166        if len(relationships) > 1:
167            _merge_relationships_and_add_to_payload(relationships, payload)
168        else:
169            payload.add_element(relationships[0])
170
171
172def bump_relationship(
173    spdx2_relationship: Spdx2_Relationship,
174    document_namespace: str,
175    counter: int,
176) -> Optional[Union[Relationship, SoftwareDependencyRelationship]]:
177    completeness, to = determine_completeness_and_to(spdx2_relationship.related_spdx_element_id)
178    spdx_id = "#".join([document_namespace, f"SPDXRef-Relationship-{counter}"])
179    relationship_class, relationship_type, parameters = relationship_mapping[spdx2_relationship.relationship_type]
180    if relationship_class is None:
181        print_missing_conversion(spdx2_relationship.relationship_type.name, 0)
182        return
183
184    swap_direction = parameters.get("swap", False)
185
186    if swap_direction:
187        if not to:
188            print_missing_conversion("Swapped Relationship to NoAssertion/None", 0)
189            return
190        from_element = to[0]
191        to = [spdx2_relationship.spdx_element_id]
192    else:
193        from_element = spdx2_relationship.spdx_element_id
194
195    if relationship_class == SoftwareDependencyRelationship:
196        from_element = spdx2_relationship.spdx_element_id
197
198        return SoftwareDependencyRelationship(
199            spdx_id,
200            f"{document_namespace}#{from_element}",
201            relationship_type,
202            [f"{document_namespace}#{t}" for t in to],
203            comment=spdx2_relationship.comment,
204            completeness=completeness,
205            scope=parameters.get("scope"),
206            software_linkage=parameters.get("linkage"),
207            conditionality=parameters.get("conditionality"),
208        )
209
210    return Relationship(
211        spdx_id,
212        f"{document_namespace}#{from_element}",
213        relationship_type,
214        [f"{document_namespace}#{t}" for t in to],
215        comment=spdx2_relationship.comment,
216        completeness=completeness,
217    )
218
219
220def determine_completeness_and_to(
221    related_spdx_element_id: Union[str, SpdxNone, SpdxNoAssertion]
222) -> Tuple[Optional[RelationshipCompleteness], List[str]]:
223    if isinstance(related_spdx_element_id, SpdxNoAssertion):
224        completeness = RelationshipCompleteness.NOASSERTION
225        to = []
226    elif isinstance(related_spdx_element_id, SpdxNone):
227        completeness = RelationshipCompleteness.COMPLETE
228        to = []
229    else:
230        completeness = None
231        to = [related_spdx_element_id]
232    return completeness, to
233
234
235def _merge_relationships_and_add_to_payload(relationships: List[Relationship], payload: Payload):
236    to = []
237    completeness = None
238    spdx_id = None
239    merged_relationship = relationships[0]
240    for merged_relationship in relationships:
241        if merged_relationship.comment:
242            payload.add_element(merged_relationship)
243            continue
244        if merged_relationship.completeness:
245            if completeness and completeness != merged_relationship.completeness:
246                logging.warning(
247                    f"Contradicting information about completeness of relationship: {merged_relationship}", sys.stderr
248                )
249            else:
250                completeness = merged_relationship.completeness
251
252        to += merged_relationship.to
253        spdx_id = merged_relationship.spdx_id
254    if to:
255        merged_relationship.spdx_id = spdx_id
256        merged_relationship.to = to
257        merged_relationship.completeness = completeness
258        merged_relationship.comment = None
259        payload.add_element(merged_relationship)