5008105195

Committed 17 May 2023 09:34PM UTC coverage: 94.782% (-0.04%) from 94.822%

Build Type

github

Committed by Brandon Lum

Commit Message

change packageVerification code for 2.1,2.2 to omitempty

Pull Request Pull Request #215: Fixing some optional params: copyrightText, licenseListVersion, packageVerificationCode

Run Details

7157 of 7551 relevant lines covered (94.78%)

15.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.23

/spdx/v2/v2_2/tagvalue/reader/parser.go

// Package parser2v2 contains functions to read, load and parse
// SPDX tag-value files, version 2.2.
// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
package reader

import (
        "fmt"

        "github.com/spdx/tools-golang/spdx/v2/common"
        spdx "github.com/spdx/tools-golang/spdx/v2/v2_2"
        "github.com/spdx/tools-golang/tagvalue/reader"
)

// ParseTagValues takes a list of (tag, value) pairs, parses it and returns
// a pointer to a parsed SPDX Document.
func ParseTagValues(tvs []reader.TagValuePair) (*spdx.Document, error) {
        parser := tvParser{}
        for _, tv := range tvs {
                err := parser.parsePair(tv.Tag, tv.Value)
                if err != nil {
                        return nil, err
                }
        }
        if parser.file != nil && parser.file.FileSPDXIdentifier == nullSpdxElementId {
                return nil, fmt.Errorf("file with FileName %s does not have SPDX identifier", parser.file.FileName)
        }
        if parser.pkg != nil && parser.pkg.PackageSPDXIdentifier == nullSpdxElementId {
                return nil, fmt.Errorf("package with PackageName %s does not have SPDX identifier", parser.pkg.PackageName)
        }
        return parser.doc, nil
}

func (parser *tvParser) parsePair(tag string, value string) error {
        switch parser.st {
        case psStart:
                return parser.parsePairFromStart(tag, value)
        case psCreationInfo:
                return parser.parsePairFromCreationInfo(tag, value)
        case psPackage:
                return parser.parsePairFromPackage(tag, value)
        case psFile:
                return parser.parsePairFromFile(tag, value)
        case psSnippet:
                return parser.parsePairFromSnippet(tag, value)
        case psOtherLicense:
                return parser.parsePairFromOtherLicense(tag, value)
        case psReview:
                return parser.parsePairFromReview(tag, value)
        default:
                return fmt.Errorf("parser state %v not recognized when parsing (%s, %s)", parser.st, tag, value)
        }
}

func (parser *tvParser) parsePairFromStart(tag string, value string) error {
        // fail if not in Start parser state
        if parser.st != psStart {
                return fmt.Errorf("got invalid state %v in parsePairFromStart", parser.st)
        }

        // create an SPDX Document data struct if we don't have one already
        if parser.doc == nil {
                parser.doc = &spdx.Document{ExternalDocumentReferences: []spdx.ExternalDocumentRef{}}
        }

        switch tag {
        case "DocumentComment":
                parser.doc.DocumentComment = value
        case "SPDXVersion":
                parser.doc.SPDXVersion = value
        case "DataLicense":
                parser.doc.DataLicense = value
        case "SPDXID":
                eID, err := extractElementID(value)
                if err != nil {
                        return err
                }
                parser.doc.SPDXIdentifier = eID
        case "DocumentName":
                parser.doc.DocumentName = value
        case "DocumentNamespace":
                parser.doc.DocumentNamespace = value
        case "ExternalDocumentRef":
                documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value)
                if err != nil {
                        return err
                }
                edr := spdx.ExternalDocumentRef{
                        DocumentRefID: documentRefID,
                        URI:           uri,
                        Checksum:      common.Checksum{Algorithm: common.ChecksumAlgorithm(alg), Value: checksum},
                }
                parser.doc.ExternalDocumentReferences = append(parser.doc.ExternalDocumentReferences, edr)
        default:
                // move to Creation Info parser state
                parser.st = psCreationInfo
                return parser.parsePairFromCreationInfo(tag, value)
        }

        return nil
}

1	// Package parser2v2 contains functions to read, load and parse
2	// SPDX tag-value files, version 2.2.
3	// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
4	package reader
5
6	import (
7	"fmt"
8
9	"github.com/spdx/tools-golang/spdx/v2/common"
10	spdx "github.com/spdx/tools-golang/spdx/v2/v2_2"
11	"github.com/spdx/tools-golang/tagvalue/reader"
12	)
13
14	// ParseTagValues takes a list of (tag, value) pairs, parses it and returns
15	// a pointer to a parsed SPDX Document.
16	func ParseTagValues(tvs []reader.TagValuePair) (*spdx.Document, error) {	3✔
17	parser := tvParser{}	3✔
18	for _, tv := range tvs {	14✔
19	err := parser.parsePair(tv.Tag, tv.Value)	11✔
20	if err != nil {	11✔
21	return nil, err	×
22	}	×
23	}
24	if parser.file != nil && parser.file.FileSPDXIdentifier == nullSpdxElementId {	4✔
25	return nil, fmt.Errorf("file with FileName %s does not have SPDX identifier", parser.file.FileName)	1✔
26	}	1✔
27	if parser.pkg != nil && parser.pkg.PackageSPDXIdentifier == nullSpdxElementId {	3✔
28	return nil, fmt.Errorf("package with PackageName %s does not have SPDX identifier", parser.pkg.PackageName)	1✔
29	}	1✔
30	return parser.doc, nil	1✔
31	}
32
33	func (parser *tvParser) parsePair(tag string, value string) error {	133✔
34	switch parser.st {	133✔
35	case psStart:	12✔
36	return parser.parsePairFromStart(tag, value)	12✔
37	case psCreationInfo:	47✔
38	return parser.parsePairFromCreationInfo(tag, value)	47✔
39	case psPackage:	16✔
40	return parser.parsePairFromPackage(tag, value)	16✔
41	case psFile:	21✔
42	return parser.parsePairFromFile(tag, value)	21✔
43	case psSnippet:	12✔
44	return parser.parsePairFromSnippet(tag, value)	12✔
45	case psOtherLicense:	13✔
46	return parser.parsePairFromOtherLicense(tag, value)	13✔
47	case psReview:	12✔
48	return parser.parsePairFromReview(tag, value)	12✔
49	default:	×
50	return fmt.Errorf("parser state %v not recognized when parsing (%s, %s)", parser.st, tag, value)	×
51	}
52	}
53
54	func (parser *tvParser) parsePairFromStart(tag string, value string) error {	15✔
55	// fail if not in Start parser state	15✔
56	if parser.st != psStart {	16✔
57	return fmt.Errorf("got invalid state %v in parsePairFromStart", parser.st)	1✔
58	}	1✔
59
60	// create an SPDX Document data struct if we don't have one already
61	if parser.doc == nil {	18✔
62	parser.doc = &spdx.Document{ExternalDocumentReferences: []spdx.ExternalDocumentRef{}}	4✔
63	}	4✔
64
65	switch tag {	14✔
66	case "DocumentComment":	2✔
67	parser.doc.DocumentComment = value	2✔
68	case "SPDXVersion":	4✔
69	parser.doc.SPDXVersion = value	4✔
70	case "DataLicense":	3✔
71	parser.doc.DataLicense = value	3✔
72	case "SPDXID":	3✔
73	eID, err := extractElementID(value)	3✔
74	if err != nil {	3✔
75	return err	×
76	}	×
77	parser.doc.SPDXIdentifier = eID	3✔
78	case "DocumentName":	×
79	parser.doc.DocumentName = value	×
80	case "DocumentNamespace":	×
81	parser.doc.DocumentNamespace = value	×
82	case "ExternalDocumentRef":	×
83	documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value)	×
84	if err != nil {	×
85	return err	×
86	}	×
87	edr := spdx.ExternalDocumentRef{	×
88	DocumentRefID: documentRefID,	×
89	URI: uri,	×
90	Checksum: common.Checksum{Algorithm: common.ChecksumAlgorithm(alg), Value: checksum},	×
91	}	×
92	parser.doc.ExternalDocumentReferences = append(parser.doc.ExternalDocumentReferences, edr)	×
93	default:	2✔
94	// move to Creation Info parser state	2✔
95	parser.st = psCreationInfo	2✔
96	return parser.parsePairFromCreationInfo(tag, value)	2✔
97	}
98
99	return nil	12✔
100	}

spdx / tools-golang / 5008105195

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous