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\n line_or_no_assertion_or_none : TEXT")
216    def p_text(self, p):
217        p[0] = str_from_text(p[1])
218
219    @grammar_rule(
220        "text_or_line : LINE\n line_or_no_assertion : LINE\nline_or_no_assertion_or_none : LINE\n"
221        "text_or_line : NO_ASSERTION\n text_or_line : NONE"
222    )
223    def p_line(self, p):
224        p[0] = p[1]
225
226    @grammar_rule(
227        "license_or_no_assertion_or_none : NO_ASSERTION\n actor_or_no_assertion : NO_ASSERTION\n"
228        "line_or_no_assertion : NO_ASSERTION\n line_or_no_assertion_or_none : NO_ASSERTION"
229    )
230    def p_no_assertion(self, p):
231        p[0] = SpdxNoAssertion()
232
233    @grammar_rule("license_or_no_assertion_or_none : NONE\n line_or_no_assertion_or_none : NONE")
234    def p_none(self, p):
235        p[0] = SpdxNone()
236
237    @grammar_rule("license_or_no_assertion_or_none : LINE")
238    def p_license(self, p):
239        try:
240            p[0] = get_spdx_licensing().parse(p[1])
241        except ExpressionError as err:
242            error_message = f"Error while parsing license expression: {p[1]}"
243            if err.args:
244                error_message += f": {err.args[0]}"
245            self.current_element["logger"].append(error_message)
246
247    @grammar_rule("actor_or_no_assertion : PERSON_VALUE\n | ORGANIZATION_VALUE")
248    def p_actor_values(self, p):
249        p[0] = ActorParser.parse_actor(p[1])
250
251    @grammar_rule("spdx_id : SPDX_ID LINE")
252    def p_spdx_id(self, p):
253        # As all SPDX Ids share the same tag, there is no knowing which spdx_id belongs to the document.
254        # We assume that to be the first spdx_id we encounter. As the specification does not explicitly require this,
255        # our approach might lead to unwanted behavior when the document's SPDX Id is defined later in the document.
256        if "spdx_id" in self.creation_info:
257            self.current_element["spdx_id"] = p[2]
258        else:
259            self.creation_info["spdx_id"] = p[2]
260
261    # parsing methods for creation info / document level
262
263    @grammar_rule(
264        "license_list_version : LICENSE_LIST_VERSION error\n document_comment : DOC_COMMENT error\n "
265        "document_namespace : DOC_NAMESPACE error\n data_license : DOC_LICENSE error\n "
266        "doc_name : DOC_NAME error\n ext_doc_ref : EXT_DOC_REF error\n spdx_version : DOC_VERSION error\n "
267        "creator_comment : CREATOR_COMMENT error\n creator : CREATOR error\n created : CREATED error"
268    )
269    def p_creation_info_value_error(self, p):
270        self.creation_info["logger"].append(
271            f"Error while parsing {p[1]}: Token did not match specified grammar rule. Line: {p.lineno(1)}"
272        )
273
274    @grammar_rule(
275        "document_comment : DOC_COMMENT text_or_line\n document_namespace : DOC_NAMESPACE LINE\n "
276        "data_license : DOC_LICENSE LINE\n spdx_version : DOC_VERSION LINE\n "
277        "creator_comment : CREATOR_COMMENT text_or_line\n doc_name : DOC_NAME LINE"
278    )
279    def p_generic_value_creation_info(self, p):
280        set_value(p, self.creation_info)
281
282    @grammar_rule("license_list_version : LICENSE_LIST_VERSION LINE")
283    def p_license_list_version(self, p):
284        set_value(p, self.creation_info, method_to_apply=Version.from_string)
285
286    @grammar_rule("ext_doc_ref : EXT_DOC_REF LINE")
287    def p_external_document_ref(self, p):
288        external_doc_ref_regex = re.compile(r"(.*)(\s*SHA1:\s*[a-f0-9]{40})")
289        external_doc_ref_match = external_doc_ref_regex.match(p[2])
290        if not external_doc_ref_match:
291            self.creation_info["logger"].append(
292                f"Error while parsing ExternalDocumentRef: Couldn't match Checksum. Line: {p.lineno(1)}"
293            )
294            return
295        try:
296            document_ref_id, document_uri = external_doc_ref_match.group(1).strip().split(" ")
297        except ValueError:
298            self.creation_info["logger"].append(
299                f"Error while parsing ExternalDocumentRef: Couldn't split the first part of the value into "
300                f"document_ref_id and document_uri. Line: {p.lineno(1)}"
301            )
302            return
303        checksum = parse_checksum(external_doc_ref_match.group(2).strip())
304        external_document_ref = ExternalDocumentRef(document_ref_id, document_uri, checksum)
305        self.creation_info.setdefault("external_document_refs", []).append(external_document_ref)
306
307    @grammar_rule("creator : CREATOR PERSON_VALUE\n| CREATOR TOOL_VALUE\n| CREATOR ORGANIZATION_VALUE")
308    def p_creator(self, p):
309        self.creation_info.setdefault("creators", []).append(ActorParser.parse_actor(p[2]))
310
311    @grammar_rule("created : CREATED ISO8601_DATE")
312    def p_created(self, p):
313        set_value(p, self.creation_info, method_to_apply=datetime_from_str)
314
315    # parsing methods for extracted licensing info
316
317    @grammar_rule("license_cross_ref : LICENSE_CROSS_REF LINE")
318    def p_extracted_cross_reference(self, p):
319        if self.check_that_current_element_matches_class_for_value(ExtractedLicensingInfo, p.lineno(1)):
320            self.current_element.setdefault("cross_references", []).append(p[2])
321
322    # parsing methods for file
323
324    @grammar_rule("file_contributor : FILE_CONTRIBUTOR LINE")
325    def p_file_contributor(self, p):
326        if self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
327            self.current_element.setdefault("contributors", []).append(p[2])
328
329    @grammar_rule("file_attribution_text : FILE_ATTRIBUTION_TEXT text_or_line")
330    def p_file_attribution_text(self, p):
331        if self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
332            self.current_element.setdefault("attribution_texts", []).append(p[2])
333
334    @grammar_rule("file_license_info : FILE_LICENSE_INFO license_or_no_assertion_or_none")
335    def p_file_license_info(self, p):
336        if self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
337            self.current_element.setdefault("license_info_in_file", []).append(p[2])
338
339    @grammar_rule("file_type : FILE_TYPE LINE")
340    def p_file_type(self, p):
341        if not self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
342            return
343        try:
344            file_type = FileType[p[2].strip()]
345        except KeyError:
346            self.current_element["logger"].append(f"Invalid FileType: {p[2]}. Line {p.lineno(1)}")
347            return
348        self.current_element.setdefault("file_types", []).append(file_type)
349
350    @grammar_rule("file_checksum : FILE_CHECKSUM CHECKSUM")
351    def p_file_checksum(self, p):
352        if not self.check_that_current_element_matches_class_for_value(File, p.lineno(1)):
353            return
354        checksum = parse_checksum(p[2])
355        self.current_element.setdefault("checksums", []).append(checksum)
356
357    # parsing methods for package
358
359    @grammar_rule("pkg_attribution_text : PKG_ATTRIBUTION_TEXT text_or_line")
360    def p_pkg_attribution_text(self, p):
361        self.check_that_current_element_matches_class_for_value(Package, p.lineno(1))
362        self.current_element.setdefault("attribution_texts", []).append(p[2])
363
364    @grammar_rule(
365        "pkg_external_ref : PKG_EXTERNAL_REF LINE PKG_EXTERNAL_REF_COMMENT text_or_line\n | PKG_EXTERNAL_REF LINE"
366    )
367    def p_pkg_external_refs(self, p):
368        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
369            return
370        try:
371            category, reference_type, locator = p[2].split(" ")
372        except ValueError:
373            self.current_element["logger"].append(
374                f"Couldn't split PackageExternalRef in category, reference_type and locator. Line: {p.lineno(1)}"
375            )
376            return
377        comment = None
378        if len(p) == 5:
379            comment = p[4]
380        try:
381            category = ExternalPackageRefCategory[category.replace("-", "_")]
382        except KeyError:
383            self.current_element["logger"].append(
384                f"Invalid ExternalPackageRefCategory: {category}. Line: {p.lineno(1)}"
385            )
386            return
387        try:
388            external_package_ref = construct_or_raise_parsing_error(
389                ExternalPackageRef,
390                {"category": category, "reference_type": reference_type, "locator": locator, "comment": comment},
391            )
392        except SPDXParsingError as err:
393            self.current_element["logger"].append(err.get_messages())
394            return
395        self.current_element.setdefault("external_references", []).append(external_package_ref)
396
397    @grammar_rule("pkg_license_info : PKG_LICENSE_INFO license_or_no_assertion_or_none")
398    def p_pkg_license_info_from_file(self, p):
399        if self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
400            self.current_element.setdefault("license_info_from_files", []).append(p[2])
401
402    @grammar_rule("pkg_checksum : PKG_CHECKSUM CHECKSUM")
403    def p_pkg_checksum(self, p):
404        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
405            return
406        checksum = parse_checksum(p[2])
407        self.current_element.setdefault("checksums", []).append(checksum)
408
409    @grammar_rule("verification_code : PKG_VERIFICATION_CODE LINE")
410    def p_pkg_verification_code(self, p):
411        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
412            return
413
414        if "verification_code" in self.current_element:
415            self.current_element["logger"].append(f"Multiple values for {p[1]} found. Line: {p.lineno(1)}")
416            return
417        verif_code_regex = re.compile(r"([0-9a-f]{40})\s*(\(excludes:\s*(.+)\))?", re.UNICODE)
418        verif_code_code_grp = 1
419        verif_code_exc_files_grp = 3
420        match = verif_code_regex.match(p[2])
421        if not match:
422            self.current_element["logger"].append(
423                f"Error while parsing {p[1]}: Value did not match expected format. Line: {p.lineno(1)}"
424            )
425            return
426        value = match.group(verif_code_code_grp)
427        excluded_files = None
428        if match.group(verif_code_exc_files_grp):
429            excluded_files = match.group(verif_code_exc_files_grp).split(",")
430        self.current_element["verification_code"] = PackageVerificationCode(value, excluded_files)
431
432    @grammar_rule("files_analyzed : PKG_FILES_ANALYZED LINE")
433    def p_pkg_files_analyzed(self, p):
434        if not self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
435            return
436        if "files_analyzed" in self.current_element:
437            self.current_element["logger"].append(f"Multiple values for {p[1]} found. Line: {p.lineno(1)}")
438            return
439        if p[2] == "true":
440            self.current_element["files_analyzed"] = True
441        elif p[2] == "false":
442            self.current_element["files_analyzed"] = False
443        else:
444            self.current_element["logger"].append(
445                f'The value of FilesAnalyzed must be either "true" or "false", but is: {p[2]}'
446            )
447
448    @grammar_rule("primary_package_purpose : PRIMARY_PACKAGE_PURPOSE LINE")
449    def p_primary_package_purpose(self, p):
450        if self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
451            set_value(p, self.current_element, method_to_apply=lambda x: PackagePurpose[x.replace("-", "_")])
452
453    @grammar_rule(
454        "built_date : BUILT_DATE ISO8601_DATE\n release_date : RELEASE_DATE ISO8601_DATE\n "
455        "valid_until_date : VALID_UNTIL_DATE ISO8601_DATE"
456    )
457    def p_package_dates(self, p):
458        if self.check_that_current_element_matches_class_for_value(Package, p.lineno(1)):
459            set_value(p, self.current_element, method_to_apply=datetime_from_str)
460
461    # parsing methods for snippet
462
463    @grammar_rule("snippet_attribution_text : SNIPPET_ATTRIBUTION_TEXT text_or_line")
464    def p_snippet_attribution_text(self, p):
465        if self.check_that_current_element_matches_class_for_value(Snippet, p.lineno(1)):
466            self.current_element.setdefault("attribution_texts", []).append(p[2])
467
468    @grammar_rule("snippet_license_info : SNIPPET_LICENSE_INFO license_or_no_assertion_or_none")
469    def p_snippet_license_info(self, p):
470        if self.check_that_current_element_matches_class_for_value(Snippet, p.lineno(1)):
471            self.current_element.setdefault("license_info_in_snippet", []).append(p[2])
472
473    @grammar_rule("snippet_byte_range : SNIPPET_BYTE_RANGE LINE\n snippet_line_range : SNIPPET_LINE_RANGE LINE")
474    def p_snippet_range(self, p):
475        if not self.check_that_current_element_matches_class_for_value(Snippet, p.lineno(1)):
476            return
477
478        argument_name = TAG_DATA_MODEL_FIELD[p[1]][1]
479        if argument_name in self.current_element:
480            self.current_element["logger"].append(f"Multiple values for {p[1]} found. Line: {p.lineno(1)}")
481            return
482        range_re = re.compile(r"^(\d+):(\d+)$", re.UNICODE)
483        if not range_re.match(p[2].strip()):
484            self.current_element["logger"].append(
485                f"Value for {p[1]} doesn't match valid range pattern. " f"Line: {p.lineno(1)}"
486            )
487            return
488        startpoint = int(p[2].split(":")[0])
489        endpoint = int(p[2].split(":")[-1])
490        self.current_element[argument_name] = startpoint, endpoint
491
492    # parsing methods for annotation
493
494    @grammar_rule("annotator : ANNOTATOR PERSON_VALUE\n| ANNOTATOR TOOL_VALUE\n| ANNOTATOR ORGANIZATION_VALUE")
495    def p_annotator(self, p):
496        self.initialize_new_current_element(Annotation)
497        set_value(p, self.current_element, method_to_apply=ActorParser.parse_actor)
498
499    @grammar_rule("annotation_date : ANNOTATION_DATE ISO8601_DATE")
500    def p_annotation_date(self, p):
501        if self.check_that_current_element_matches_class_for_value(Annotation, p.lineno(1)):
502            set_value(p, self.current_element, method_to_apply=datetime_from_str)
503
504    @grammar_rule("annotation_type : ANNOTATION_TYPE LINE")
505    def p_annotation_type(self, p):
506        if self.check_that_current_element_matches_class_for_value(Annotation, p.lineno(1)):
507            set_value(p, self.current_element, method_to_apply=lambda x: AnnotationType[x])
508
509    # parsing methods for relationship
510
511    @grammar_rule("relationship : RELATIONSHIP LINE RELATIONSHIP_COMMENT text_or_line\n " "| RELATIONSHIP LINE")
512    def p_relationship(self, p):
513        self.initialize_new_current_element(Relationship)
514        try:
515            spdx_element_id, relationship_type, related_spdx_element_id = p[2].split(" ")
516        except ValueError:
517            self.current_element["logger"].append(
518                f"Relationship couldn't be split in spdx_element_id, relationship_type and "
519                f"related_spdx_element. Line: {p.lineno(1)}"
520            )
521            return
522        try:
523            self.current_element["relationship_type"] = RelationshipType[relationship_type]
524        except KeyError:
525            self.current_element["logger"].append(f"Invalid RelationshipType {relationship_type}. Line: {p.lineno(1)}")
526        if related_spdx_element_id == "NONE":
527            related_spdx_element_id = SpdxNone()
528        if related_spdx_element_id == "NOASSERTION":
529            related_spdx_element_id = SpdxNoAssertion()
530        self.current_element["related_spdx_element_id"] = related_spdx_element_id
531        self.current_element["spdx_element_id"] = spdx_element_id
532        if len(p) == 5:
533            self.current_element["comment"] = p[4]
534
535    def p_error(self, p):
536        pass
537
538    def parse(self, text):
539        # entry point for the tag-value parser
540        self.yacc.parse(text, lexer=self.lex)
541        # this constructs the last remaining element; all other elements are constructed at the start of
542        # their subsequent element
543        self.construct_current_element()
544
545        # To be able to parse creation info values if they appear in between other elements, e.g. packages, we use
546        # two different dictionaries to collect the creation info and all other elements. Therefore, we have a separate
547        # logger for the creation info whose messages we need to add to the main logger to than raise all collected
548        # messages at once.
549        creation_info_logger = self.creation_info.pop("logger")
550        if creation_info_logger.has_messages():
551            self.logger.extend([f"Error while parsing CreationInfo: {creation_info_logger.get_messages()}"])
552
553        raise_parsing_error_if_logger_has_messages(self.logger)
554        creation_info = construct_or_raise_parsing_error(CreationInfo, self.creation_info)
555        self.elements_built["creation_info"] = creation_info
556        document = construct_or_raise_parsing_error(Document, self.elements_built)
557        return document
558
559    def initialize_new_current_element(self, clazz: Any):
560        self.construct_current_element()
561        self.current_element["class"] = clazz
562
563    def check_that_current_element_matches_class_for_value(self, expected_class, line_number) -> bool:
564        if "class" not in self.current_element or expected_class != self.current_element["class"]:
565            self.logger.append(
566                f"Element {expected_class.__name__} is not the current element in scope, probably the expected tag to "
567                f"start the element ({ELEMENT_EXPECTED_START_TAG[expected_class.__name__]}) is missing. "
568                f"Line: {line_number}"
569            )
570            return False
571        return True
572
573    def construct_current_element(self):
574        if "class" not in self.current_element:
575            # This happens when the first element is initialized via initialize_new_current_element() or if the first
576            # element is missing its expected starting tag. In both cases we are unable to construct an element.
577            return
578
579        clazz = self.current_element.pop("class")
580        try:
581            raise_parsing_error_if_logger_has_messages(self.current_element.pop("logger"), clazz.__name__)
582            self.elements_built.setdefault(CLASS_MAPPING[clazz.__name__], []).append(
583                construct_or_raise_parsing_error(clazz, self.current_element)
584            )
585            if clazz == File:
586                self.check_for_preceding_package_and_build_contains_relationship()
587        except SPDXParsingError as err:
588            self.logger.extend(err.get_messages())
589        self.current_element = {"logger": Logger()}
590
591    def check_for_preceding_package_and_build_contains_relationship(self):
592        file_spdx_id = self.current_element["spdx_id"]
593        if "packages" not in self.elements_built:
594            return
595        # We assume that all files that are not contained in a package precede any package information. Any file
596        # information that follows any package information is assigned to the last parsed package by creating a
597        # corresponding contains relationship.
598        # (see https://spdx.github.io/spdx-spec/v2.3/composition-of-an-SPDX-document/#5.2.2)
599        if not self.elements_built["packages"]:
600            self.logger.append(
601                f"Error while building contains relationship for file {file_spdx_id}, "
602                f"preceding package was not parsed successfully."
603            )
604            return
605        package_spdx_id = self.elements_built["packages"][-1].spdx_id
606        relationship = Relationship(package_spdx_id, RelationshipType.CONTAINS, file_spdx_id)
607        if relationship not in self.elements_built.setdefault("relationships", []):
608            self.elements_built["relationships"].append(relationship)