spdx_tools.spdx.parser.tagvalue.parser

  1# Copyright (c) 2014 Ahmed H. Ismail
  2# Copyright (c) 2023 spdx contributors
  3# SPDX-License-Identifier: Apache-2.0
  4# Licensed under the Apache License, Version 2.0 (the "License");
  5# you may not use this file except in compliance with the License.
  6# You may obtain a copy of the License at
  7#     http://www.apache.org/licenses/LICENSE-2.0
  8# Unless required by applicable law or agreed to in writing, software
  9# distributed under the License is distributed on an "AS IS" BASIS,
 10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 11# See the License for the specific language governing permissions and
 12# limitations under the License.
 13
 14import re
 15
 16from beartype.typing import Any, Dict, List
 17from license_expression import ExpressionError, get_spdx_licensing
 18from ply import yacc
 19from ply.yacc import LRParser
 20
 21from spdx_tools.spdx.datetime_conversions import datetime_from_str
 22from spdx_tools.spdx.model import (
 23    Annotation,
 24    AnnotationType,
 25    CreationInfo,
 26    Document,
 27    ExternalDocumentRef,
 28    ExternalPackageRef,
 29    ExternalPackageRefCategory,
 30    ExtractedLicensingInfo,
 31    File,
 32    FileType,
 33    Package,
 34    PackagePurpose,
 35    PackageVerificationCode,
 36    Relationship,
 37    RelationshipType,
 38    Snippet,
 39    SpdxNoAssertion,
 40    SpdxNone,
 41    Version,
 42)
 43from spdx_tools.spdx.parser.actor_parser import ActorParser
 44from spdx_tools.spdx.parser.error import SPDXParsingError
 45from spdx_tools.spdx.parser.logger import Logger
 46from spdx_tools.spdx.parser.parsing_functions import (
 47    construct_or_raise_parsing_error,
 48    raise_parsing_error_if_logger_has_messages,
 49)
 50from spdx_tools.spdx.parser.tagvalue.helper_methods import (
 51    TAG_DATA_MODEL_FIELD,
 52    grammar_rule,
 53    parse_checksum,
 54    set_value,
 55    str_from_text,
 56)
 57from spdx_tools.spdx.parser.tagvalue.lexer import SPDXLexer
 58
 59CLASS_MAPPING = dict(
 60    File="files",
 61    Annotation="annotations",
 62    Relationship="relationships",
 63    Snippet="snippets",
 64    Package="packages",
 65    ExtractedLicensingInfo="extracted_licensing_info",
 66)
 67ELEMENT_EXPECTED_START_TAG = dict(
 68    File="FileName",
 69    Annotation="Annotator",
 70    Relationship="Relationship",
 71    Snippet="SnippetSPDXID",
 72    Package="PackageName",
 73    ExtractedLicensingInfo="LicenseID",
 74)
 75
 76
 77class Parser:
 78    tokens: List[str]
 79    logger: Logger
 80    current_element: Dict[str, Any]
 81    creation_info: Dict[str, Any]
 82    elements_built: Dict[str, Any]
 83    lex: SPDXLexer
 84    yacc: LRParser
 85
 86    def __init__(self, **kwargs):
 87        self.tokens = SPDXLexer.tokens
 88        self.logger = Logger()
 89        self.current_element = {"logger": Logger()}
 90        self.creation_info = {"logger": Logger()}
 91        self.elements_built = dict()
 92        self.lex = SPDXLexer()
 93        self.lex.build(reflags=re.UNICODE)
 94        self.yacc = yacc.yacc(module=self, **kwargs)
 95
 96    @grammar_rule("start : start attrib ")
 97    def p_start_start_attrib(self, p):
 98        pass
 99
100    @grammar_rule("start : attrib ")
101    def p_start_attrib(self, p):
102        pass
103
104    @grammar_rule(
105        "attrib : spdx_version\n| spdx_id\n| data_license\n| doc_name\n| document_comment\n| document_namespace\n| "
106        "creator\n| created\n| creator_comment\n| license_list_version\n| ext_doc_ref\n"
107        # attributes for file
108        "| file_name\n| file_type\n| file_checksum\n| file_license_concluded\n| file_license_info\n"
109        "| file_copyright_text\n| file_license_comment\n| file_attribution_text\n| file_notice\n| file_comment\n"
110        "| file_contributor\n"
111        # attributes for annotation
112        "| annotator\n| annotation_date\n| annotation_comment\n| annotation_type\n| annotation_spdx_id\n"
113        # attributes for relationship
114        "| relationship\n"
115        # attributes for snippet
116        "| snippet_spdx_id\n| snippet_name\n| snippet_comment\n| snippet_attribution_text\n| snippet_copyright_text\n"
117        "| snippet_license_comment\n| file_spdx_id\n| snippet_license_concluded\n| snippet_license_info\n"
118        "| snippet_byte_range\n| snippet_line_range\n"
119        # attributes for package
120        "| package_name\n| package_version\n| download_location\n| files_analyzed\n| homepage\n"
121        "| summary\n| source_info\n| pkg_file_name\n| supplier\n| originator\n| pkg_checksum\n"
122        "| verification_code\n| description\n| pkg_comment\n| pkg_attribution_text\n| pkg_license_declared\n"
123        "| pkg_license_concluded\n| pkg_license_info\n| pkg_license_comment\n| pkg_copyright_text\n"
124        "| pkg_external_ref\n| primary_package_purpose\n| built_date\n| release_date\n| valid_until_date\n"
125        # attributes for extracted licensing info
126        "| license_id\n| extracted_text\n| license_name\n| license_cross_ref\n| lic_comment\n"
127        "| unknown_tag "
128    )
129    def p_attrib(self, p):
130        pass
131
132    # general parsing methods
133    @grammar_rule(
134        "license_id : LICENSE_ID error\n license_cross_ref : LICENSE_CROSS_REF error\n "
135        "lic_comment : LICENSE_COMMENT error\n license_name : LICENSE_NAME error\n "
136        "extracted_text : LICENSE_TEXT error\n "
137        "file_name : FILE_NAME error\n file_contributor : FILE_CONTRIBUTOR error\n "
138        "file_notice : FILE_NOTICE error\n file_copyright_text : FILE_COPYRIGHT_TEXT error\n "
139        "file_license_comment : FILE_LICENSE_COMMENT error\n "
140        "file_license_info : FILE_LICENSE_INFO error\n file_comment : FILE_COMMENT error\n "
141        "file_checksum : FILE_CHECKSUM error\n file_license_concluded : FILE_LICENSE_CONCLUDED error\n "
142        "file_type : FILE_TYPE error\n file_attribution_text : FILE_ATTRIBUTION_TEXT error\n "
143        "package_name : PKG_NAME error\n pkg_attribution_text : PKG_ATTRIBUTION_TEXT error\n "
144        "description : PKG_DESCRIPTION error\n pkg_comment : PKG_COMMENT error\n "
145        "summary : PKG_SUMMARY error\n pkg_copyright_text : PKG_COPYRIGHT_TEXT error\n "
146        "pkg_external_ref : PKG_EXTERNAL_REF error\n pkg_license_comment : PKG_LICENSE_COMMENT error\n "
147        "pkg_license_declared : PKG_LICENSE_DECLARED error\n pkg_license_info : PKG_LICENSE_INFO error \n "
148        "pkg_license_concluded : PKG_LICENSE_CONCLUDED error\n source_info : PKG_SOURCE_INFO error\n "
149        "homepage : PKG_HOMEPAGE error\n pkg_checksum : PKG_CHECKSUM error\n "
150        "verification_code : PKG_VERIFICATION_CODE error\n originator : PKG_ORIGINATOR error\n "
151        "download_location : PKG_DOWNLOAD_LOCATION error\n files_analyzed : PKG_FILES_ANALYZED error\n "
152        "supplier : PKG_SUPPLIER error\n pkg_file_name : PKG_FILE_NAME error\n "
153        "package_version : PKG_VERSION error\n primary_package_purpose : PRIMARY_PACKAGE_PURPOSE error\n "
154        "built_date : BUILT_DATE error\n release_date : RELEASE_DATE error\n "
155        "valid_until_date : VALID_UNTIL_DATE error\n snippet_spdx_id : SNIPPET_SPDX_ID error\n "
156        "snippet_name : SNIPPET_NAME error\n snippet_comment : SNIPPET_COMMENT error\n "
157        "snippet_attribution_text : SNIPPET_ATTRIBUTION_TEXT error\n "
158        "snippet_copyright_text : SNIPPET_COPYRIGHT_TEXT error\n "
159        "snippet_license_comment : SNIPPET_LICENSE_COMMENT error\n file_spdx_id : SNIPPET_FILE_SPDXID error\n "
160        "snippet_license_concluded : SNIPPET_LICENSE_CONCLUDED error\n "
161        "snippet_license_info : SNIPPET_LICENSE_INFO error\n "
162        "snippet_byte_range : SNIPPET_BYTE_RANGE error\n snippet_line_range : SNIPPET_LINE_RANGE error\n "
163        "annotator : ANNOTATOR error\n annotation_date : ANNOTATION_DATE error\n "
164        "annotation_comment : ANNOTATION_COMMENT error\n annotation_type : ANNOTATION_TYPE error\n "
165        "annotation_spdx_id : ANNOTATION_SPDX_ID error\n relationship : RELATIONSHIP error"
166    )
167    def p_current_element_error(self, p):
168        if p[1] in ELEMENT_EXPECTED_START_TAG.values():
169            self.initialize_new_current_element(TAG_DATA_MODEL_FIELD[p[1]][0])
170        self.current_element["logger"].append(
171            f"Error while parsing {p[1]}: Token did not match specified grammar rule. Line: {p.lineno(1)}"
172        )
173
174    @grammar_rule(
175        "license_name : LICENSE_NAME line_or_no_assertion\n extracted_text : LICENSE_TEXT text_or_line\n "
176        "lic_comment : LICENSE_COMMENT text_or_line\n license_id : LICENSE_ID LINE\n "
177        "file_name : FILE_NAME LINE \n file_notice : FILE_NOTICE text_or_line\n "
178        "file_copyright_text : FILE_COPYRIGHT_TEXT line_or_no_assertion_or_none\n "
179        "file_license_comment : FILE_LICENSE_COMMENT text_or_line\n "
180        "file_comment : FILE_COMMENT text_or_line\n "
181        "file_license_concluded : FILE_LICENSE_CONCLUDED license_or_no_assertion_or_none\n "
182        "package_name : PKG_NAME LINE\n description : PKG_DESCRIPTION text_or_line\n "
183        "summary : PKG_SUMMARY text_or_line\n source_info : PKG_SOURCE_INFO text_or_line\n "
184        "homepage : PKG_HOMEPAGE line_or_no_assertion_or_none\n "
185        "download_location : PKG_DOWNLOAD_LOCATION line_or_no_assertion_or_none\n "
186        "originator : PKG_ORIGINATOR actor_or_no_assertion\n supplier : PKG_SUPPLIER actor_or_no_assertion\n "
187        "pkg_comment : PKG_COMMENT text_or_line\n "
188        "pkg_copyright_text : PKG_COPYRIGHT_TEXT line_or_no_assertion_or_none\n "
189        "pkg_license_declared : PKG_LICENSE_DECLARED license_or_no_assertion_or_none\n "
190        "pkg_file_name : PKG_FILE_NAME LINE\n "
191        "pkg_license_concluded : PKG_LICENSE_CONCLUDED license_or_no_assertion_or_none\n "
192        "package_version : PKG_VERSION LINE\n pkg_license_comment : PKG_LICENSE_COMMENT text_or_line\n "
193        "snippet_spdx_id : SNIPPET_SPDX_ID LINE\n snippet_name : SNIPPET_NAME LINE\n "
194        "snippet_comment : SNIPPET_COMMENT text_or_line\n "
195        "snippet_copyright_text : SNIPPET_COPYRIGHT_TEXT line_or_no_assertion_or_none\n "
196        "snippet_license_comment : SNIPPET_LICENSE_COMMENT text_or_line\n "
197        "file_spdx_id : SNIPPET_FILE_SPDXID LINE\n "
198        "snippet_license_concluded : SNIPPET_LICENSE_CONCLUDED license_or_no_assertion_or_none\n "
199        "annotation_spdx_id : ANNOTATION_SPDX_ID LINE\n "
200        "annotation_comment : ANNOTATION_COMMENT text_or_line"
201    )
202    def p_generic_value(self, p):
203        if p[1] in ELEMENT_EXPECTED_START_TAG.values():
204            self.initialize_new_current_element(TAG_DATA_MODEL_FIELD[p[1]][0])
205        if self.check_that_current_element_matches_class_for_value(TAG_DATA_MODEL_FIELD[p[1]][0], p.lineno(1)):
206            set_value(p, self.current_element)
207
208    @grammar_rule(
209        "unknown_tag : UNKNOWN_TAG text_or_line\n | UNKNOWN_TAG ISO8601_DATE\n | UNKNOWN_TAG PERSON_VALUE \n"
210        "| UNKNOWN_TAG"
211    )
212    def p_unknown_tag(self, p):
213        self.logger.append(f"Unknown tag provided in line {p.lineno(1)}")
214
215    @grammar_rule("text_or_line : TEXT")
216    def p_text(self, p):
217        p[0] = str_from_text(p[1])
218
219    @grammar_rule("text_or_line : LINE\n line_or_no_assertion : LINE\nline_or_no_assertion_or_none : text_or_line")
220    def p_line(self, p):
221        p[0] = p[1]
222
223    @grammar_rule(
224        "license_or_no_assertion_or_none : NO_ASSERTION\n actor_or_no_assertion : NO_ASSERTION\n"
225        "line_or_no_assertion : NO_ASSERTION\n line_or_no_assertion_or_none : NO_ASSERTION"
226    )
227    def p_no_assertion(self, p):
228        p[0] = SpdxNoAssertion()
229
230    @grammar_rule("license_or_no_assertion_or_none : NONE\n line_or_no_assertion_or_none : NONE")
231    def p_none(self, p):
232        p[0] = SpdxNone()
233
234    @grammar_rule("license_or_no_assertion_or_none : LINE")
235    def p_license(self, p):
236        try:
237            p[0] = get_spdx_licensing().parse(p[1])
238        except ExpressionError as err:
239            error_message = f"Error while parsing license expression: {p[1]}"
240            if err.args:
241                error_message += f": {err.args[0]}"
242            self.current_element["logger"].append(error_message)
243
244    @grammar_rule("actor_or_no_assertion : PERSON_VALUE\n | ORGANIZATION_VALUE")
245    def p_actor_values(self, p):
246        p[0] = ActorParser.parse_actor(p[1])
247
248    @grammar_rule("spdx_id : SPDX_ID LINE")
249    def p_spdx_id(self, p):
250        # As all SPDX Ids share the same tag, there is no knowing which spdx_id belongs to the document.
251        # We assume that to be the first spdx_id we encounter. As the specification does not explicitly require this,
252        # our approach might lead to unwanted behavior when the document's SPDX Id is defined later in the document.
253        if "spdx_id" in self.creation_info:
254            self.current_element["spdx_id"] = p[2]
255        else:
256            self.creation_info["spdx_id"] = p[2]
257
258    # parsing methods for creation info / document level
259
260    @grammar_rule(
261        "license_list_version : LICENSE_LIST_VERSION error\n document_comment : DOC_COMMENT error\n "
262        "document_namespace : DOC_NAMESPACE error\n data_license : DOC_LICENSE error\n "
263        "doc_name : DOC_NAME error\n ext_doc_ref : EXT_DOC_REF error\n spdx_version : DOC_VERSION error\n "
264        "creator_comment : CREATOR_COMMENT error\n creator : CREATOR error\n created : CREATED error"
265    )
266    def p_creation_info_value_error(self, p):
267        self.creation_info["logger"].append(
268            f"Error while parsing {p[1]}: Token did not match specified grammar rule. Line: {p.lineno(1)}"
269        )
270
271    @grammar_rule(
272        "document_comment : DOC_COMMENT text_or_line\n document_namespace : DOC_NAMESPACE LINE\n "
273        "data_license : DOC_LICENSE LINE\n spdx_version : DOC_VERSION LINE\n "
274        "creator_comment : CREATOR_COMMENT text_or_line\n doc_name : DOC_NAME LINE"
275    )
276    def p_generic_value_creation_info(self, p):
277        set_value(p, self.creation_info)
278
279    @grammar_rule("license_list_version : LICENSE_LIST_VERSION LINE")
280    def p_license_list_version(self, p):
281        set_value(p, self.creation_info, method_to_apply=Version.from_string)
282
283    @grammar_rule("ext_doc_ref : EXT_DOC_REF LINE")
284    def p_external_document_ref(self, p):
285        external_doc_ref_regex = re.compile(r"(.*)(\s*SHA1:\s*[a-f0-9]{40})")
286        external_doc_ref_match = external_doc_ref_regex.match(p[2])
287        if not external_doc_ref_match:
288            self.creation_info["logger"].append(
289                f"Error while parsing ExternalDocumentRef: Couldn't match Checksum. Line: {p.lineno(1)}"
290            )
291            return
292        try:
293            document_ref_id, document_uri = external_doc_ref_match.group(1).strip().split(" ")
294        except ValueError:
295            self.creation_info["logger"].append(
296                f"Error while parsing ExternalDocumentRef: Couldn't split the first part of the value into "
297                f"document_ref_id and document_uri. Line: {p.lineno(1)}"
298            )
299            return
300        checksum = parse_checksum(external_doc_ref_match.group(2).strip())
301        external_document_ref = ExternalDocumentRef(document_ref_id, document_uri, checksum)
302        self.creation_info.setdefault("external_document_refs", []).append(external_document_ref)
303
304    @grammar_rule("creator : CREATOR PERSON_VALUE\n| CREATOR TOOL_VALUE\n| CREATOR ORGANIZATION_VALUE")
305    def p_creator(self, p):
306        self.creation_info.setdefault("creators", []).append(ActorParser.parse_actor(p[2]))
307
308    @grammar_rule("created : CREATED ISO8601_DATE")
309    def p_created(self, p):
310        set_value(p, self.creation_info, method_to_apply=datetime_from_str)
311
312    # parsing methods for extracted licensing info
313
314    @grammar_rule("license_cross_ref : LICENSE_CROSS_REF LINE")
315    def p_extracted_cross_reference(self, p):
316        if self.check_that_current_element_matches_class_for_value(ExtractedLicensingInfo, p.lineno(1)):
317            self.current_element.setdefault("cross_references", []).append(p[2])
318
319    # parsing methods for file
320
321    @grammar_rule("file_contributor : FILE_CONTRIBUTOR LINE")
322    def p_file_contributor(self, p):
323        if self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
324            self.current_element.setdefault("contributors", []).append(p[2])
325
326    @grammar_rule("file_attribution_text : FILE_ATTRIBUTION_TEXT text_or_line")
327    def p_file_attribution_text(self, p):
328        if self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
329            self.current_element.setdefault("attribution_texts", []).append(p[2])
330
331    @grammar_rule("file_license_info : FILE_LICENSE_INFO license_or_no_assertion_or_none")
332    def p_file_license_info(self, p):
333        if self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
334            self.current_element.setdefault("license_info_in_file", []).append(p[2])
335
336    @grammar_rule("file_type : FILE_TYPE LINE")
337    def p_file_type(self, p):
338        if not self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
339            return
340        try:
341            file_type = FileType[p[2].strip()]
342        except KeyError:
343            self.current_element["logger"].append(f"Invalid FileType: {p[2]}. Line {p.lineno(1)}")
344            return
345        self.current_element.setdefault("file_types", []).append(file_type)
346
347    @grammar_rule("file_checksum : FILE_CHECKSUM CHECKSUM")
348    def p_file_checksum(self, p):
349        if not self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
350            return
351        checksum = parse_checksum(p[2])
352        self.current_element.setdefault("checksums", []).append(checksum)
353
354    # parsing methods for package
355
356    @grammar_rule("pkg_attribution_text : PKG_ATTRIBUTION_TEXT text_or_line")
357    def p_pkg_attribution_text(self, p):
358        self.check_that_current_element_matches_class_for_value(Package, p.lineno(1))
359        self.current_element.setdefault("attribution_texts", []).append(p[2])
360
361    @grammar_rule(
362        "pkg_external_ref : PKG_EXTERNAL_REF LINE PKG_EXTERNAL_REF_COMMENT text_or_line\n | PKG_EXTERNAL_REF LINE"
363    )
364    def p_pkg_external_refs(self, p):
365        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
366            return
367        try:
368            category, reference_type, locator = p[2].split(" ")
369        except ValueError:
370            self.current_element["logger"].append(
371                f"Couldn't split PackageExternalRef in category, reference_type and locator. Line: {p.lineno(1)}"
372            )
373            return
374        comment = None
375        if len(p) == 5:
376            comment = p[4]
377        try:
378            category = ExternalPackageRefCategory[category.replace("-", "_")]
379        except KeyError:
380            self.current_element["logger"].append(
381                f"Invalid ExternalPackageRefCategory: {category}. Line: {p.lineno(1)}"
382            )
383            return
384        try:
385            external_package_ref = construct_or_raise_parsing_error(
386                ExternalPackageRef,
387                {"category": category, "reference_type": reference_type, "locator": locator, "comment": comment},
388            )
389        except SPDXParsingError as err:
390            self.current_element["logger"].append(err.get_messages())
391            return
392        self.current_element.setdefault("external_references", []).append(external_package_ref)
393
394    @grammar_rule("pkg_license_info : PKG_LICENSE_INFO license_or_no_assertion_or_none")
395    def p_pkg_license_info_from_file(self, p):
396        if self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
397            self.current_element.setdefault("license_info_from_files", []).append(p[2])
398
399    @grammar_rule("pkg_checksum : PKG_CHECKSUM CHECKSUM")
400    def p_pkg_checksum(self, p):
401        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
402            return
403        checksum = parse_checksum(p[2])
404        self.current_element.setdefault("checksums", []).append(checksum)
405
406    @grammar_rule("verification_code : PKG_VERIFICATION_CODE LINE")
407    def p_pkg_verification_code(self, p):
408        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
409            return
410
411        if "verification_code" in self.current_element:
412            self.current_element["logger"].append(f"Multiple values for {p[1]} found. Line: {p.lineno(1)}")
413            return
414        verif_code_regex = re.compile(r"([0-9a-f]{40})\s*(\(excludes:\s*(.+)\))?", re.UNICODE)
415        verif_code_code_grp = 1
416        verif_code_exc_files_grp = 3
417        match = verif_code_regex.match(p[2])
418        if not match:
419            self.current_element["logger"].append(
420                f"Error while parsing {p[1]}: Value did not match expected format. Line: {p.lineno(1)}"
421            )
422            return
423        value = match.group(verif_code_code_grp)
424        excluded_files = None
425        if match.group(verif_code_exc_files_grp):
426            excluded_files = match.group(verif_code_exc_files_grp).split(",")
427        self.current_element["verification_code"] = PackageVerificationCode(value, excluded_files)
428
429    @grammar_rule("files_analyzed : PKG_FILES_ANALYZED LINE")
430    def p_pkg_files_analyzed(self, p):
431        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
432            return
433        if "files_analyzed" in self.current_element:
434            self.current_element["logger"].append(f"Multiple values for {p[1]} found. Line: {p.lineno(1)}")
435            return
436        if p[2] == "true":
437            self.current_element["files_analyzed"] = True
438        elif p[2] == "false":
439            self.current_element["files_analyzed"] = False
440        else:
441            self.current_element["logger"].append(
442                f'The value of FilesAnalyzed must be either "true" or "false", but is: {p[2]}'
443            )
444
445    @grammar_rule("primary_package_purpose : PRIMARY_PACKAGE_PURPOSE LINE")
446    def p_primary_package_purpose(self, p):
447        if self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
448            set_value(p, self.current_element, method_to_apply=lambda x: PackagePurpose[x.replace("-", "_")])
449
450    @grammar_rule(
451        "built_date : BUILT_DATE ISO8601_DATE\n release_date : RELEASE_DATE ISO8601_DATE\n "
452        "valid_until_date : VALID_UNTIL_DATE ISO8601_DATE"
453    )
454    def p_package_dates(self, p):
455        if self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
456            set_value(p, self.current_element, method_to_apply=datetime_from_str)
457
458    # parsing methods for snippet
459
460    @grammar_rule("snippet_attribution_text : SNIPPET_ATTRIBUTION_TEXT text_or_line")
461    def p_snippet_attribution_text(self, p):
462        if self.check_that_current_element_matches_class_for_value(Snippet, p.lineno(1)):
463            self.current_element.setdefault("attribution_texts", []).append(p[2])
464
465    @grammar_rule("snippet_license_info : SNIPPET_LICENSE_INFO license_or_no_assertion_or_none")
466    def p_snippet_license_info(self, p):
467        if self.check_that_current_element_matches_class_for_value(Snippet, p.lineno(1)):
468            self.current_element.setdefault("license_info_in_snippet", []).append(p[2])
469
470    @grammar_rule("snippet_byte_range : SNIPPET_BYTE_RANGE LINE\n snippet_line_range : SNIPPET_LINE_RANGE LINE")
471    def p_snippet_range(self, p):
472        if not self.check_that_current_element_matches_class_for_value(Snippet, p.lineno(1)):
473            return
474
475        argument_name = TAG_DATA_MODEL_FIELD[p[1]][1]
476        if argument_name in self.current_element:
477            self.current_element["logger"].append(f"Multiple values for {p[1]} found. Line: {p.lineno(1)}")
478            return
479        range_re = re.compile(r"^(\d+):(\d+)$", re.UNICODE)
480        if not range_re.match(p[2].strip()):
481            self.current_element["logger"].append(
482                f"Value for {p[1]} doesn't match valid range pattern. " f"Line: {p.lineno(1)}"
483            )
484            return
485        startpoint = int(p[2].split(":")[0])
486        endpoint = int(p[2].split(":")[-1])
487        self.current_element[argument_name] = startpoint, endpoint
488
489    # parsing methods for annotation
490
491    @grammar_rule("annotator : ANNOTATOR PERSON_VALUE\n| ANNOTATOR TOOL_VALUE\n| ANNOTATOR ORGANIZATION_VALUE")
492    def p_annotator(self, p):
493        self.initialize_new_current_element(Annotation)
494        set_value(p, self.current_element, method_to_apply=ActorParser.parse_actor)
495
496    @grammar_rule("annotation_date : ANNOTATION_DATE ISO8601_DATE")
497    def p_annotation_date(self, p):
498        if self.check_that_current_element_matches_class_for_value(Annotation, p.lineno(1)):
499            set_value(p, self.current_element, method_to_apply=datetime_from_str)
500
501    @grammar_rule("annotation_type : ANNOTATION_TYPE LINE")
502    def p_annotation_type(self, p):
503        if self.check_that_current_element_matches_class_for_value(Annotation, p.lineno(1)):
504            set_value(p, self.current_element, method_to_apply=lambda x: AnnotationType[x])
505
506    # parsing methods for relationship
507
508    @grammar_rule("relationship : RELATIONSHIP LINE RELATIONSHIP_COMMENT text_or_line\n " "| RELATIONSHIP LINE")
509    def p_relationship(self, p):
510        self.initialize_new_current_element(Relationship)
511        try:
512            spdx_element_id, relationship_type, related_spdx_element_id = p[2].split(" ")
513        except ValueError:
514            self.current_element["logger"].append(
515                f"Relationship couldn't be split in spdx_element_id, relationship_type and "
516                f"related_spdx_element. Line: {p.lineno(1)}"
517            )
518            return
519        try:
520            self.current_element["relationship_type"] = RelationshipType[relationship_type]
521        except KeyError:
522            self.current_element["logger"].append(f"Invalid RelationshipType {relationship_type}. Line: {p.lineno(1)}")
523        if related_spdx_element_id == "NONE":
524            related_spdx_element_id = SpdxNone()
525        if related_spdx_element_id == "NOASSERTION":
526            related_spdx_element_id = SpdxNoAssertion()
527        self.current_element["related_spdx_element_id"] = related_spdx_element_id
528        self.current_element["spdx_element_id"] = spdx_element_id
529        if len(p) == 5:
530            self.current_element["comment"] = p[4]
531
532    def p_error(self, p):
533        pass
534
535    def parse(self, text):
536        # entry point for the tag-value parser
537        self.yacc.parse(text, lexer=self.lex)
538        # this constructs the last remaining element; all other elements are constructed at the start of
539        # their subsequent element
540        self.construct_current_element()
541
542        # To be able to parse creation info values if they appear in between other elements, e.g. packages, we use
543        # two different dictionaries to collect the creation info and all other elements. Therefore, we have a separate
544        # logger for the creation info whose messages we need to add to the main logger to than raise all collected
545        # messages at once.
546        creation_info_logger = self.creation_info.pop("logger")
547        if creation_info_logger.has_messages():
548            self.logger.extend([f"Error while parsing CreationInfo: {creation_info_logger.get_messages()}"])
549
550        raise_parsing_error_if_logger_has_messages(self.logger)
551        creation_info = construct_or_raise_parsing_error(CreationInfo, self.creation_info)
552        self.elements_built["creation_info"] = creation_info
553        document = construct_or_raise_parsing_error(Document, self.elements_built)
554        return document
555
556    def initialize_new_current_element(self, clazz: Any):
557        self.construct_current_element()
558        self.current_element["class"] = clazz
559
560    def check_that_current_element_matches_class_for_value(self, expected_class, line_number) -> bool:
561        if "class" not in self.current_element or expected_class != self.current_element["class"]:
562            self.logger.append(
563                f"Element {expected_class.__name__} is not the current element in scope, probably the expected tag to "
564                f"start the element ({ELEMENT_EXPECTED_START_TAG[expected_class.__name__]}) is missing. "
565                f"Line: {line_number}"
566            )
567            return False
568        return True
569
570    def construct_current_element(self):
571        if "class" not in self.current_element:
572            # This happens when the first element is initialized via initialize_new_current_element() or if the first
573            # element is missing its expected starting tag. In both cases we are unable to construct an element.
574            return
575
576        clazz = self.current_element.pop("class")
577        try:
578            raise_parsing_error_if_logger_has_messages(self.current_element.pop("logger"), clazz.__name__)
579            self.elements_built.setdefault(CLASS_MAPPING[clazz.__name__], []).append(
580                construct_or_raise_parsing_error(clazz, self.current_element)
581            )
582            if clazz == File:
583                self.check_for_preceding_package_and_build_contains_relationship()
584        except SPDXParsingError as err:
585            self.logger.extend(err.get_messages())
586        self.current_element = {"logger": Logger()}
587
588    def check_for_preceding_package_and_build_contains_relationship(self):
589        file_spdx_id = self.current_element["spdx_id"]
590        if "packages" not in self.elements_built:
591            return
592        # We assume that all files that are not contained in a package precede any package information. Any file
593        # information that follows any package information is assigned to the last parsed package by creating a
594        # corresponding contains relationship.
595        # (see https://spdx.github.io/spdx-spec/v2.3/composition-of-an-SPDX-document/#5.2.2)
596        if not self.elements_built["packages"]:
597            self.logger.append(
598                f"Error while building contains relationship for file {file_spdx_id}, "
599                f"preceding package was not parsed successfully."
600            )
601            return
602        package_spdx_id = self.elements_built["packages"][-1].spdx_id
603        relationship = Relationship(package_spdx_id, RelationshipType.CONTAINS, file_spdx_id)
604        if relationship not in self.elements_built.setdefault("relationships", []):
605            self.elements_built["relationships"].append(relationship)