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_3/tagvalue/reader/parser.go

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

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