wip

Author: bfabio

fields.go

@@ -8,7 +8,7 @@ import (
 	spdxValidator "github.com/kyoh86/go-spdx/spdx"
 	"github.com/alranel/go-vcsurl/v2"
 
-	urlutil "github.com/italia/publiccode-parser-go/v3/internal"
+	urlutil "github.com/italia/publiccode-parser-go/v4/internal"
 )
 
 // validateFields validates publiccode with additional rules not validatable

go.mod

@@ -1,4 +1,4 @@
-module github.com/italia/publiccode-parser-go/v3
+module github.com/italia/publiccode-parser-go/v4
 
 require (
 	github.com/alranel/go-vcsurl/v2 v2.0.2

parser.go

@@ -18,33 +18,36 @@ import (
 	"github.com/go-playground/validator/v10"
 	"github.com/alranel/go-vcsurl/v2"
 
-	publiccodeValidator "github.com/italia/publiccode-parser-go/v3/validators"
-	urlutil "github.com/italia/publiccode-parser-go/v3/internal"
+	publiccodeValidator "github.com/italia/publiccode-parser-go/v4/validators"
+	urlutil "github.com/italia/publiccode-parser-go/v4/internal"
 )
 
-// Parser is a helper class for parsing publiccode.yml files.
-type Parser struct {
-	PublicCode PublicCode
-
+type ParserConfig struct {
 	// DisableNetwork disables all network tests (URL existence and Oembed). This
 	// results in much faster parsing.
-	DisableNetwork bool
+    DisableNetwork bool
 
 	// Domain will have domain specific settings, including basic auth if provided
 	// this will avoid strong quota limit imposed by code hosting platform
-	Domain Domain
+    Domain Domain
 
 	// The name of the branch used to check for existence of the files referenced
 	// in the publiccode.yml
-	Branch string
+    Branch string
 
-	// The URL used as based of relative files in publiccode.yml (eg. authorsFile)
-	// It can be a local file with the 'file' scheme.
-	baseURL *url.URL
+	// TODO: doc
+	BaseURL string
+}
+
+// Parser is a helper class for parsing publiccode.yml files.
+type Parser struct {
+	disableNetwork bool
+	domain Domain
+	branch string
 
-	// The URL pointing to the publiccode.yml file.
+	// The URL used as base of relative files in publiccode.yml (eg. authorsFile)
 	// It can be a local file with the 'file' scheme.
-	file    *url.URL
+	baseURL *url.URL
 }
 
 // Domain is a single code hosting service.
@@ -56,132 +59,55 @@ type Domain struct {
 }
 
 // ParseInDomain wrapper func to be in domain env
-func (p *Parser) ParseInDomain(in []byte, host string, utf []string, ba []string) error {
-	p.Domain = Domain{
-		Host:        host,
-		UseTokenFor: utf,
-		BasicAuth:   ba,
-	}
-
-	return p.ParseBytes(in)
-}
-
-func getNodes(key string, node *yaml.Node) (*yaml.Node, *yaml.Node) {
-	for i := 0; i < len(node.Content); i += 2 {
-		childNode := *node.Content[i]
-
-		if childNode.Value == key {
-			return &childNode, node.Content[i + 1]
-		}
-	}
-
-	return nil, nil
-}
-
-func getPositionInFile(key string, node yaml.Node) (int, int) {
-	var n *yaml.Node = &node
+// func (p *Parser) ParseInDomain(in []byte, host string, utf []string, ba []string) error {
+// 	p.Domain = Domain{
+// 		Host:        host,
+// 		UseTokenFor: utf,
+// 		BasicAuth:   ba,
+// 	}
 
-	keys := strings.Split(key, ".")
-	for _, path := range keys[:len(keys) - 1] {
-		_, n = getNodes(path, n)
-
-		// This should not happen, but let's be defensive
-		if (n == nil) {
-			return 0, 0
-		}
-	}
-
-	parentNode := n
+// 	return p.ParseBytes(in)
+// }
 
-	n, _ = getNodes(keys[len(keys) - 1], n)
-
-	if (n != nil) {
-		return n.Line, n.Column
-	} else {
-		return parentNode.Line, parentNode.Column
+// NewParser initializes a new Parser object and returns it.
+// TODO
+func NewParser(config ParserConfig) (*Parser, error) {
+// func NewParserWithPath(file string, path string) (*Parser, error) {
+	parser := Parser{
+		disableNetwork: config.DisableNetwork,
+		domain:         config.Domain,
+		branch:         config.Branch,
 	}
-}
-
-// getKeyAtLine returns the key name at line "line" for the YAML document
-// represented at parentNode.
-func getKeyAtLine(parentNode yaml.Node, line int, path string) string {
-	var key = path
 
-	for i, currNode := range parentNode.Content {
-		// If this node is a mapping and the index is odd it means
-		// we are not looking at a key, but at its value. Skip it.
-		if parentNode.Kind == yaml.MappingNode && i%2 != 0 && currNode.Kind == yaml.ScalarNode {
-			continue
-		}
-
-		// This node is a key of a mapping type
-		if parentNode.Kind == yaml.MappingNode && i%2 == 0 {
-			if path == "" {
-				key = currNode.Value
-			} else {
-				key = fmt.Sprintf("%s.%s", path, currNode.Value)
-			}
-		}
-
-		// We want the scalar node (ie. key) not the mapping node which
-		// doesn't have a tag name even if it has the same line number
-		if currNode.Line == line && parentNode.Kind == yaml.MappingNode && currNode.Kind == yaml.ScalarNode {
-			return key
-		}
-
-		if currNode.Kind != yaml.ScalarNode {
-			if k := getKeyAtLine(*currNode, line, key); k != "" {
-				return k
-			}
+	if config.BaseURL != "" {
+		if p.baseURL, err := toURL(config.BaseURL); err != nil {
+			return nil, err
 		}
 	}
 
-	return ""
+	return &parser, nil
 }
 
-func toValidationError(errorText string, node *yaml.Node) ValidationError {
-	r := regexp.MustCompile(`(line ([0-9]+): )`)
-	matches := r.FindStringSubmatch(errorText)
-
-	line := 0
-	if (len(matches) > 1) {
-		line, _ = strconv.Atoi(matches[2])
-		errorText = strings.ReplaceAll(errorText, matches[1], "")
-	}
-
-	// Transform unmarshalling errors messages to a user friendlier message
-	r = regexp.MustCompile("^cannot unmarshal")
-	if r.MatchString(errorText) {
-		errorText = "wrong type for this field"
-	}
-
-	var key string
-	if node != nil {
-		key = getKeyAtLine(*node, line, "")
-	}
+// ParseStreams reads the data and tries to parse it. Returns an error if fails.
+func (p *Parser) ParseStream(in io.Reader) (PublicCode, error) {
+	var ve ValidationResults
 
-	return ValidationError{
-		Key: key,
-		Description: errorText,
-		Line: line,
-		Column: 1,
+	bytes, err := io.ReadAll(file)
+	if err != nil {
+		ve = append(ve, newValidationError("", fmt.Sprintf("Can't read the stream: %v", err)))
+		return ve
 	}
-}
-
-// ParseBytes loads the yaml bytes and tries to parse it. Return an error if fails.
-func (p *Parser) ParseBytes(in []byte) error {
-	var ve ValidationResults
 
-	if !utf8.Valid(in) {
-		ve = append(ve,newValidationError("", "Invalid UTF-8"))
+	if !utf8.Valid(bytes) {
+		ve = append(ve, newValidationError("", "Invalid UTF-8"))
 		return ve
 	}
 
 	// First, decode the YAML into yaml.Node so we can access line and column
 	// numbers.
 	var node yaml.Node
 
-	d := yaml.NewDecoder(bytes.NewReader(in))
+	d := yaml.NewDecoder(in)
 	d.KnownFields(true)
 	err := d.Decode(&node)
 
@@ -323,58 +249,136 @@ func (p *Parser) ParseBytes(in []byte) error {
 	return ve
 }
 
-func (p *Parser) Parse() error {
-	var data []byte
-	var err error
+func (p *Parser) Parse(uri string) (PublicCode, error) {
+	var stream io.Reader
+
+	if u, err = toURL(file); err != nil {
+		return nil, err
+	}
 
-	if p.file.Scheme == "file" {
-		data, err = os.ReadFile(p.file.Path)
+	if u.Scheme == "file" {
+		stream, err := os.Open(u.Path)
 		if err != nil {
 			return err
 		}
 	} else {
-		resp, err := http.Get(p.file.String())
+		resp, err := http.Get(uri)
 		if err != nil {
 			return err
 		}
 		defer resp.Body.Close()
 
-		data, err = io.ReadAll(resp.Body)
-		if err != nil {
-			return err
-		}
+		stream = resp.Body
 	}
 
-	return p.ParseBytes(data)
+	return p.ParseStream(data)
 }
 
-// NewParser initializes a new Parser object and returns it.
-// TODO
-func NewParser(file string) (*Parser, error) {
-	return NewParserWithPath(file, "")
+// ToYAML converts parser.PublicCode into YAML again.
+func (p *Parser) ToYAML() ([]byte, error) {
+	return yaml.Marshal(p.PublicCode)
 }
 
-// TODO doc
-// empty string disables it and enables remote
-func NewParserWithPath(file string, path string) (*Parser, error) {
-	var p Parser
+func getNodes(key string, node *yaml.Node) (*yaml.Node, *yaml.Node) {
+	for i := 0; i < len(node.Content); i += 2 {
+		childNode := *node.Content[i]
 
-	var err error
-	if p.file, err = toURL(file); err != nil {
-		return nil, err
+		if childNode.Value == key {
+			return &childNode, node.Content[i + 1]
+		}
 	}
-	if path != "" {
-		if p.baseURL, err = toURL(path); err != nil {
-			return nil, err
+
+	return nil, nil
+}
+
+func getPositionInFile(key string, node yaml.Node) (int, int) {
+	var n *yaml.Node = &node
+
+	keys := strings.Split(key, ".")
+	for _, path := range keys[:len(keys) - 1] {
+		_, n = getNodes(path, n)
+
+		// This should not happen, but let's be defensive
+		if (n == nil) {
+			return 0, 0
 		}
 	}
 
-	return &p, nil
+	parentNode := n
+
+	n, _ = getNodes(keys[len(keys) - 1], n)
+
+	if (n != nil) {
+		return n.Line, n.Column
+	} else {
+		return parentNode.Line, parentNode.Column
+	}
 }
 
-// ToYAML converts parser.PublicCode into YAML again.
-func (p *Parser) ToYAML() ([]byte, error) {
-	return yaml.Marshal(p.PublicCode)
+// getKeyAtLine returns the key name at line "line" for the YAML document
+// represented at parentNode.
+func getKeyAtLine(parentNode yaml.Node, line int, path string) string {
+	var key = path
+
+	for i, currNode := range parentNode.Content {
+		// If this node is a mapping and the index is odd it means
+		// we are not looking at a key, but at its value. Skip it.
+		if parentNode.Kind == yaml.MappingNode && i%2 != 0 && currNode.Kind == yaml.ScalarNode {
+			continue
+		}
+
+		// This node is a key of a mapping type
+		if parentNode.Kind == yaml.MappingNode && i%2 == 0 {
+			if path == "" {
+				key = currNode.Value
+			} else {
+				key = fmt.Sprintf("%s.%s", path, currNode.Value)
+			}
+		}
+
+		// We want the scalar node (ie. key) not the mapping node which
+		// doesn't have a tag name even if it has the same line number
+		if currNode.Line == line && parentNode.Kind == yaml.MappingNode && currNode.Kind == yaml.ScalarNode {
+			return key
+		}
+
+		if currNode.Kind != yaml.ScalarNode {
+			if k := getKeyAtLine(*currNode, line, key); k != "" {
+				return k
+			}
+		}
+	}
+
+	return ""
+}
+
+func toValidationError(errorText string, node *yaml.Node) ValidationError {
+	r := regexp.MustCompile(`(line ([0-9]+): )`)
+	matches := r.FindStringSubmatch(errorText)
+
+	line := 0
+	if (len(matches) > 1) {
+		line, _ = strconv.Atoi(matches[2])
+		errorText = strings.ReplaceAll(errorText, matches[1], "")
+	}
+
+	// Transform unmarshalling errors messages to a user friendlier message
+	r = regexp.MustCompile("^cannot unmarshal")
+	if r.MatchString(errorText) {
+		errorText = "wrong type for this field"
+	}
+
+	var key string
+	if node != nil {
+		key = getKeyAtLine(*node, line, "")
+	}
+
+	return ValidationError{
+		Key: key,
+		Description: errorText,
+		Line: line,
+		Column: 1,
+	}
 }
 
 // TODO doc