ci_validator/gitlabcivalidator/parser.go

package gitlabcivalidator

import (
	"fmt"
	"gitflame.ru/CI_VLDR/errors"
	"gopkg.in/yaml.v3"
)

// ParseGitLabCIConfig parses the YAML and returns the GitLabCIConfig structure.
func ParseGitLabCIConfig(data []byte, ve *errors.ValidationError) (*GitLabCIConfig, error) {
	var config GitLabCIConfig
	var root yaml.Node

	// Parse YAML into the root node
	err := yaml.Unmarshal(data, &root)
	if err != nil {
		return nil, fmt.Errorf("YAML syntax error: %w", err)
	}

	// If root is empty, the YAML file is empty or invalid
	if len(root.Content) == 0 {
		return nil, fmt.Errorf(".gitlab-ci.yml file is empty or does not contain valid data")
	}

	// Expect the root node to be a YAML document
	if root.Kind != yaml.DocumentNode || len(root.Content) == 0 {
		return nil, fmt.Errorf("invalid YAML format: expected a root object")
	}

	// The main object is the first child
	mainNode := root.Content[0]

	// Decode the root object into the configuration structure
	err = mainNode.Decode(&config)
	if err != nil {
		return nil, fmt.Errorf("failed to decode GitLab CI configuration: %w", err)
	}

	// Manually parse the 'jobs' node
	for i := 0; i < len(mainNode.Content)-1; i += 2 {
		keyNode := mainNode.Content[i]
		valNode := mainNode.Content[i+1]

		if keyNode.Value == "jobs" && valNode.Kind == yaml.MappingNode {
			// 'jobs' found, parsing manually
			config.Jobs = make(map[string]*Job)

			for j := 0; j < len(valNode.Content)-1; j += 2 {
				jobKeyNode := valNode.Content[j]   // job name
				jobValNode := valNode.Content[j+1] // job definition (mapping or otherwise)

				// Create a new job with its name and positional info.
				job := &Job{
					Name:            jobKeyNode.Value,
					Line:            jobKeyNode.Line,
					Column:          jobKeyNode.Column,
					DependencyLines: make(map[string]struct{ Line, Column int }),
				}

				// If the job value is a mapping node, decode its content.
				if jobValNode.Kind == yaml.MappingNode {
					err := jobValNode.Decode(job)
					if err != nil {
						return nil, fmt.Errorf("failed to decode job '%s': %w", job.Name, err)
					}
					validateJobMapping(jobValNode, ve)
					// Process inner keys (dependencies, needs, only, etc.)
					for d := 0; d < len(jobValNode.Content)-1; d += 2 {
						depKey := jobValNode.Content[d]
						depVal := jobValNode.Content[d+1]

						if depKey.Value == "dependencies" && depVal.Kind == yaml.SequenceNode {
							for k := 0; k < len(depVal.Content); k++ {
								depNode := depVal.Content[k]
								job.Dependencies = append(job.Dependencies, depNode.Value)
								job.DependencyLines[depNode.Value] = struct {
									Line   int
									Column int
								}{depNode.Line, depNode.Column}
							}
						}

						if depKey.Value == "needs" && depVal.Kind == yaml.SequenceNode {
							job.NeedLines = make(map[string]struct {
								Line   int
								Column int
							})
							for k := 0; k < len(depVal.Content); k++ {
								needNode := depVal.Content[k]
								job.Needs = append(job.Needs, needNode.Value)
								job.NeedLines[needNode.Value] = struct {
									Line   int
									Column int
								}{needNode.Line, needNode.Column}
							}
						}

						if depKey.Value == "only" {
							if depVal.Kind == yaml.ScalarNode {
								job.Only = depVal.Value
							} else if depVal.Kind == yaml.SequenceNode {
								var arr []string
								for k := 0; k < len(depVal.Content); k++ {
									arr = append(arr, depVal.Content[k].Value)
								}
								job.Only = arr
							}
							job.OnlyLine = depKey.Line
							job.OnlyColumn = depKey.Column
						}
					}
				}
				// If jobValNode is not a mapping, leave the job with default (nil) fields.
				// Now add the job to the configuration regardless.
				config.Jobs[job.Name] = job
			}
		}
	}

	return &config, nil
}

// findUnknownRootKeysWithSpan scans the mainNode for unknown keys and returns their information.
func findUnknownRootKeysWithSpan(mainNode *yaml.Node) []errors.UnknownKeyError {
	allowedKeys := map[string]struct{}{
		"default":       {},
		"include":       {},
		"before_script": {},
		"image":         {},
		"services":      {},
		"after_script":  {},
		"variables":     {},
		"stages":        {},
		"cache":         {},
		"workflow":      {},
		"jobs":          {},
		"changes":       {},
		"paths":         {},
	}

	var unknowns []errors.UnknownKeyError
	if mainNode.Kind != yaml.MappingNode {
		return unknowns
	}

	for i := 0; i < len(mainNode.Content)-1; i += 2 {
		keyNode := mainNode.Content[i]
		if _, ok := allowedKeys[keyNode.Value]; !ok {
			endLine, endCol := keyNode.Line, keyNode.Column+len(keyNode.Value)
			unknowns = append(unknowns, errors.UnknownKeyError{
				Key:       keyNode.Value,
				Line:      keyNode.Line,
				Column:    keyNode.Column,
				EndLine:   endLine,
				EndColumn: endCol,
			})
		}
	}
	return unknowns
}