[issue-456] also parse URIRefs with the documents namespace as prefix…

… as license expression (could be ListedLicense, ExtractedLicensingInfo or simple reference) Signed-off-by: Meret Behrens <meret.behrens@tngtech.com>
spdx · meretp · Feb 22, 2023 · Feb 1, 2023 · Feb 1, 2023 · Feb 9, 2023
commit 1b8cf8277d9e851f8ced2bbe121acd215361229b
diff --git a/src/spdx/parser/rdf/file_parser.py b/src/spdx/parser/rdf/file_parser.py
@@ -34,13 +34,14 @@ def parse_file(file_node: URIRef, graph: Graph, doc_namespace: str) -> File:
             file_types.append(convert_uri_ref_to_file_type(file_type_ref))
         except KeyError:
             logger.append(f"Invalid FileType: {file_type_ref}")
-    license_concluded = parse_literal_or_no_assertion_or_none(logger, graph, file_node, SPDX_NAMESPACE.licenseConcluded,
-                                                              parsing_method=lambda x: parse_license_expression(x,
-                                                                                                                graph))
+    license_concluded = parse_literal_or_no_assertion_or_none(
+        logger, graph, file_node, SPDX_NAMESPACE.licenseConcluded,
+        parsing_method=lambda x: parse_license_expression(x, graph, doc_namespace))
     license_info_in_file = []
     for (_, _, license_info_from_files_node) in graph.triples((file_node, SPDX_NAMESPACE.licenseInfoInFile, None)):
         license_info_in_file.append(
-            get_correct_typed_value(logger, license_info_from_files_node, lambda x: parse_license_expression(x, graph)))
+            get_correct_typed_value(logger, license_info_from_files_node,
+                                    lambda x: parse_license_expression(x, graph, doc_namespace)))
     license_comment = parse_literal(logger, graph, file_node, SPDX_NAMESPACE.licenseComments)
     copyright_text = parse_literal_or_no_assertion_or_none(logger, graph, file_node, SPDX_NAMESPACE.copyrightText,
                                                            parsing_method=str)

diff --git a/src/spdx/parser/rdf/license_expression_parser.py b/src/spdx/parser/rdf/license_expression_parser.py
@@ -16,33 +16,36 @@
 from spdx.rdfschema.namespace import SPDX_NAMESPACE, LICENSE_NAMESPACE
 
 
-def parse_license_expression(license_expression_node: Node, graph: Graph) -> LicenseExpression:
+def parse_license_expression(license_expression_node: Node, graph: Graph, doc_namespace: str) -> LicenseExpression:
     spdx_licensing = get_spdx_licensing()
     expression = ""
     if license_expression_node.startswith(LICENSE_NAMESPACE):
         expression = license_expression_node.removeprefix(LICENSE_NAMESPACE)
         return spdx_licensing.parse(expression)
+    if license_expression_node.startswith(doc_namespace):
+        expression = license_expression_node.fragment
+        return spdx_licensing.parse(expression)
 
     node_type = graph.value(license_expression_node, RDF.type)
     if node_type == SPDX_NAMESPACE.ConjunctiveLicenseSet:
         members = dict()
         for index, (_, _, member_node) in enumerate(
             graph.triples((license_expression_node, SPDX_NAMESPACE.member, None))):
-            members[index] = parse_license_expression(member_node, graph)
+            members[index] = parse_license_expression(member_node, graph, doc_namespace)
         if len(members) > 2:
             raise SPDXParsingError([f"A ConjunctiveLicenseSet can only have two members."])
         expression = f"{members[0]} AND {members[1]}"
     if node_type == SPDX_NAMESPACE.DisjunctiveLicenseSet:
         members = dict()
         for index, (_, _, member_node) in enumerate(
             graph.triples((license_expression_node, SPDX_NAMESPACE.member, None))):
-            members[index] = parse_license_expression(member_node, graph)
+            members[index] = parse_license_expression(member_node, graph, doc_namespace)
         if len(members) > 2:
             raise SPDXParsingError([f"A DisjunctiveLicenseSet can only have two members."])
         expression = f"{members[0]} OR {members[1]}"
     if node_type == SPDX_NAMESPACE.WithExceptionOperator:
         license_expression = parse_license_expression(graph.value(license_expression_node, SPDX_NAMESPACE.member),
-                                                      graph)
+                                                      graph, doc_namespace)
         exception = parse_license_exception(graph.value(license_expression_node, SPDX_NAMESPACE.licenseException),
                                             graph)
         expression = f"{license_expression} WITH {exception}"
@@ -56,5 +59,3 @@ def parse_license_exception(exception_node: Node, graph: Graph) -> str:
     else:
         exception = graph.value(exception_node, SPDX_NAMESPACE.licenseExceptionId).toPython()
     return exception
-
-# need to be able to parse a ListedLicense as in spdx-spec example
diff --git a/src/spdx/parser/rdf/package_parser.py b/src/spdx/parser/rdf/package_parser.py
@@ -60,19 +60,18 @@ def parse_package(package_node: URIRef, graph: Graph, doc_namespace: str) -> Pac
     for (_, _, external_package_ref_node) in graph.triples((package_node, SPDX_NAMESPACE.externalRef, None)):
         external_package_refs.append(parse_external_package_ref(external_package_ref_node, graph))
     files_analyzed = bool(graph.value(package_node, SPDX_NAMESPACE.filesAnalyzed, default=True))
-    license_concluded = parse_literal_or_no_assertion_or_none(logger, graph, package_node,
-                                                              SPDX_NAMESPACE.licenseConcluded,
-                                                              parsing_method=lambda x: parse_license_expression(x,
-                                                                                                                graph))
-    license_declared = parse_literal_or_no_assertion_or_none(logger, graph, package_node,
-                                                             SPDX_NAMESPACE.licenseDeclared,
-                                                             parsing_method=lambda x: parse_license_expression(x,
-                                                                                                               graph))
+    license_concluded = parse_literal_or_no_assertion_or_none(
+        logger, graph, package_node, SPDX_NAMESPACE.licenseConcluded,
+        parsing_method=lambda x: parse_license_expression(x, graph, doc_namespace))
+    license_declared = parse_literal_or_no_assertion_or_none(
+        logger, graph, package_node, SPDX_NAMESPACE.licenseDeclared,
+        parsing_method=lambda x: parse_license_expression(x, graph, doc_namespace))
     license_info_from_files = []
     for (_, _, license_info_from_files_node) in graph.triples(
         (package_node, SPDX_NAMESPACE.licenseInfoFromFiles, None)):
         license_info_from_files.append(
-            get_correct_typed_value(logger, license_info_from_files_node, lambda x: parse_license_expression(x, graph)))
+            get_correct_typed_value(logger, license_info_from_files_node,
+                                    lambda x: parse_license_expression(x, graph, doc_namespace)))
     license_comment = parse_literal(logger, graph, package_node, SPDX_NAMESPACE.licenseComments)
     comment = parse_literal(logger, graph, package_node, RDFS.comment)
     summary = parse_literal(logger, graph, package_node, SPDX_NAMESPACE.summary)

diff --git a/src/spdx/parser/rdf/snippet_parser.py b/src/spdx/parser/rdf/snippet_parser.py
@@ -29,15 +29,15 @@ def parse_snippet(snippet_node: URIRef, graph: Graph, doc_namespace: str) -> Sni
     file_spdx_id = parse_spdx_id(file_spdx_id_uri, doc_namespace, graph)
     byte_range = parse_ranges(snippet_node, graph, POINTER_NAMESPACE.ByteOffsetPointer, POINTER_NAMESPACE.offset)
     line_range = parse_ranges(snippet_node, graph, POINTER_NAMESPACE.LineCharPointer, POINTER_NAMESPACE.lineNumber)
-    license_concluded = parse_literal_or_no_assertion_or_none(logger, graph, snippet_node,
-                                                              SPDX_NAMESPACE.licenseConcluded,
-                                                              parsing_method=lambda x: parse_license_expression(x,
-                                                                                                                graph))
+    license_concluded = parse_literal_or_no_assertion_or_none(
+        logger, graph, snippet_node, SPDX_NAMESPACE.licenseConcluded,
+        parsing_method=lambda x: parse_license_expression(x, graph, doc_namespace))
     license_info_in_snippet = []
     for (_, _, license_info_in_snippet_node) in graph.triples(
         (snippet_node, SPDX_NAMESPACE.licenseInfoInSnippet, None)):
         license_info_in_snippet.append(
-            get_correct_typed_value(logger, license_info_in_snippet_node, lambda x: parse_license_expression(x, graph)))
+            get_correct_typed_value(logger, license_info_in_snippet_node,
+                                    lambda x: parse_license_expression(x, graph, doc_namespace)))
     license_comment = parse_literal(logger, graph, snippet_node, SPDX_NAMESPACE.licenseComments)
     copyright_text = parse_literal_or_no_assertion_or_none(logger, graph, snippet_node, SPDX_NAMESPACE.copyrightText,
                                                            parsing_method=str)

diff --git a/tests/spdx/parser/rdf/test_license_expression_parser.py b/tests/spdx/parser/rdf/test_license_expression_parser.py
@@ -9,9 +9,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
+from unittest import TestCase
 
 from license_expression import get_spdx_licensing
 from rdflib import Graph, RDF, URIRef
+from spdx.parser.rdf import rdf_parser
 
 from spdx.parser.rdf.license_expression_parser import parse_license_expression
 from spdx.rdfschema.namespace import SPDX_NAMESPACE
@@ -23,16 +25,24 @@ def test_license_expression_parser():
     package_node = graph.value(predicate=RDF.type, object=SPDX_NAMESPACE.Package)
     license_expression_node = graph.value(subject=package_node, predicate=SPDX_NAMESPACE.licenseConcluded)
 
-    license_expression = parse_license_expression(license_expression_node, graph)
+    license_expression = parse_license_expression(license_expression_node, graph, "https://some.namespace#")
 
     assert license_expression == get_spdx_licensing().parse("GPL-2.0 AND MIT")
 
-def test_license_expression_parser_with_writer():
-    license_expression = get_spdx_licensing().parse("GPL-2.0 WITH exception")
-    graph = Graph()
-    add_license_expression_to_graph(license_expression, graph, URIRef("test"), URIRef("predicate"), "anyURI")
 
-    expression_noe = graph.value(URIRef("test"), URIRef("predicate"))
-    license_expression_parsed = parse_license_expression(expression_noe,graph)
+def test_license_expression_parser_with_coupled_licenses():
+    doc = rdf_parser.parse_from_file(
+        os.path.join(os.path.dirname(__file__), "../../data/formats/SPDXRdfExample-v2.3.spdx.rdf.xml"))
 
-    assert license_expression_parsed == license_expression
+    packages_by_spdx_id = {package.spdx_id: package for package in doc.packages}
+    files_by_spdx_id = {file.spdx_id: file for file in doc.files}
+
+    assert packages_by_spdx_id["SPDXRef-Package"].license_declared == get_spdx_licensing().parse(
+        "LGPL-2.0-only AND LicenseRef-3")
+    assert packages_by_spdx_id["SPDXRef-Package"].license_concluded == get_spdx_licensing().parse(
+        "LGPL-2.0-only OR LicenseRef-3")
+    TestCase().assertCountEqual(packages_by_spdx_id["SPDXRef-Package"].license_info_from_files,
+                                [get_spdx_licensing().parse("GPL-2.0"), get_spdx_licensing().parse("LicenseRef-1"),
+                                 get_spdx_licensing().parse("LicenseRef-2")])
+
+    assert files_by_spdx_id["SPDXRef-JenaLib"].license_concluded == get_spdx_licensing().parse("LicenseRef-1")