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

69.33

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

// Package parser2v1 contains functions to read, load and parse
// SPDX tag-value files.
// 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_1"
        "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 "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)
        case "DocumentComment":
                parser.doc.DocumentComment = value
        default:
                // move to Creation Info parser state
                parser.st = psCreationInfo
                return parser.parsePairFromCreationInfo(tag, value)
        }

        return nil
}

1	// Package parser2v1 contains functions to read, load and parse
2	// SPDX tag-value files.
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_1"
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
31	return parser.doc, nil	1✔
32	}
33
34	func (parser *tvParser) parsePair(tag string, value string) error {	128✔
35	switch parser.st {	128✔
36	case psStart:	12✔
37	return parser.parsePairFromStart(tag, value)	12✔
38	case psCreationInfo:	42✔
39	return parser.parsePairFromCreationInfo(tag, value)	42✔
40	case psPackage:	16✔
41	return parser.parsePairFromPackage(tag, value)	16✔
42	case psFile:	21✔
43	return parser.parsePairFromFile(tag, value)	21✔
44	case psSnippet:	12✔
45	return parser.parsePairFromSnippet(tag, value)	12✔
46	case psOtherLicense:	13✔
47	return parser.parsePairFromOtherLicense(tag, value)	13✔
48	case psReview:	12✔
49	return parser.parsePairFromReview(tag, value)	12✔
50	default:	×
51	return fmt.Errorf("parser state %v not recognized when parsing (%s, %s)", parser.st, tag, value)	×
52	}
53	}
54
55	func (parser *tvParser) parsePairFromStart(tag string, value string) error {	13✔
56	// fail if not in Start parser state	13✔
57	if parser.st != psStart {	14✔
58	return fmt.Errorf("got invalid state %v in parsePairFromStart", parser.st)	1✔
59	}	1✔
60
61	// create an SPDX Document data struct if we don't have one already
62	if parser.doc == nil {	16✔
63	parser.doc = &spdx.Document{	4✔
64	ExternalDocumentReferences: []spdx.ExternalDocumentRef{},	4✔
65	}	4✔
66	}	4✔
67
68	switch tag {	12✔
69	case "SPDXVersion":	4✔
70	parser.doc.SPDXVersion = value	4✔
71	case "DataLicense":	3✔
72	parser.doc.DataLicense = value	3✔
73	case "SPDXID":	3✔
74	eID, err := extractElementID(value)	3✔
75	if err != nil {	3✔
76	return err	×
77	}	×
78	parser.doc.SPDXIdentifier = eID	3✔
79	case "DocumentName":	×
80	parser.doc.DocumentName = value	×
81	case "DocumentNamespace":	×
82	parser.doc.DocumentNamespace = value	×
83	case "ExternalDocumentRef":	×
84	documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value)	×
85	if err != nil {	×
86	return err	×
87	}	×
88	edr := spdx.ExternalDocumentRef{	×
89	DocumentRefID: documentRefID,	×
90	URI: uri,	×
91	Checksum: common.Checksum{Algorithm: common.ChecksumAlgorithm(alg), Value: checksum},	×
92	}	×
93	parser.doc.ExternalDocumentReferences = append(parser.doc.ExternalDocumentReferences, edr)	×
94	case "DocumentComment":	×
95	parser.doc.DocumentComment = value	×
96	default:	2✔
97	// move to Creation Info parser state	2✔
98	parser.st = psCreationInfo	2✔
99	return parser.parsePairFromCreationInfo(tag, value)	2✔
100	}
101
102	return nil	10✔
103	}

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