Fix Yaml Parse Errors (#414)

Author: SUSTAPLE117

models/azure_pipelines.go

@@ -147,13 +147,18 @@ func (v *AzurePipelineVariables) UnmarshalYAML(value *yaml.Node) error {
 		return nil
 	}
 
-	var listFormat []AzurePipelineVariable
-	if err := value.Decode(&listFormat); err == nil {
-		for _, variable := range listFormat {
-			v.Map[variable.Name] = variable.Value
+	// Variables lists can contain name/value pairs, group references,
+	// and template references. Decode each item individually and
+	// skip non-variable entries (group, template).
+	if value.Kind == yaml.SequenceNode {
+		for _, item := range value.Content {
+			var variable AzurePipelineVariable
+			if err := item.Decode(&variable); err == nil && variable.Name != "" {
+				v.Map[variable.Name] = variable.Value
+			}
 		}
 		return nil
 	}
 
-	return fmt.Errorf("variables must be either a map or a list of objects")
+	return nil
 }

models/azure_pipelines_test.go

@@ -50,6 +50,21 @@ func TestAzurePipeline(t *testing.T) {
 				}},
 			},
 		},
+		{
+			input: "variables:\n  - group: my-variable-group\n  - name: foo\n    value: bar\n  - template: vars.yml",
+			expected: AzurePipeline{
+				Stages: []AzureStage{
+					{
+						Jobs: []AzureJob{
+							{},
+						},
+					},
+				},
+				Variables: AzurePipelineVariables{map[string]string{
+					"foo": "bar",
+				}},
+			},
+		},
 		{
 			input: `stages: [{stage: build, jobs: [{job: test, steps: [bash: asdf]}]}]`,
 			expected: AzurePipeline{

models/github_actions.go

@@ -2,10 +2,10 @@ package models
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
-	"gopkg.in/yaml.v3"
 	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 const (
@@ -64,11 +64,28 @@ type GithubActionsWith = GithubActionsEnvs
 type GithubActionsJobRunsOn StringList
 type StringList []string
 
+// StringBool accepts both YAML booleans and quoted strings like "false".
+type StringBool bool
+
+func (b *StringBool) UnmarshalYAML(node *yaml.Node) error {
+	var boolVal bool
+	if err := node.Decode(&boolVal); err == nil {
+		*b = StringBool(boolVal)
+		return nil
+	}
+	var strVal string
+	if err := node.Decode(&strVal); err != nil {
+		return fmt.Errorf("error parsing string value for string bool: %s", node.Value)
+	}
+	*b = StringBool(strVal == "true")
+	return nil
+}
+
 type GithubActionsInput struct {
-	Name        string `json:"name"`
-	Description string `json:"description,omitempty"`
-	Required    bool   `json:"required"`
-	Type        string `json:"type"`
+	Name        string     `json:"name"`
+	Description string     `json:"description,omitempty"`
+	Required    StringBool `json:"required"`
+	Type        string     `json:"type"`
 }
 
 type GithubActionsOutput struct {
@@ -553,27 +570,34 @@ type GithubActionsStrategy struct {
 	Matrix map[string]StringList `json:"matrix,omitempty" yaml:"matrix"`
 }
 
-// UnmarshalYAML parses the `strategy` block and extracts `matrix`
+// UnmarshalYAML parses the `strategy` block and extracts `matrix` dimensions.
+// It is intentionally lenient: unsupported constructs (expressions, include/exclude,
+// scalar dimensions, nested sequences) are silently skipped so that the rest of
+// the workflow still parses successfully.
 func (o *GithubActionsStrategy) UnmarshalYAML(node *yaml.Node) error {
 	if node.Kind != yaml.MappingNode {
-		return errors.New("invalid yaml node type for strategy")
+		return nil
 	}
 	for i := 0; i < len(node.Content); i += 2 {
 		key := node.Content[i].Value
 		value := node.Content[i+1]
 		if key != "matrix" {
 			continue
 		}
+		// matrix may be an expression like ${{ fromJSON(...) }}
 		if value.Kind != yaml.MappingNode {
-			return errors.New("matrix must be a mapping")
+			continue
 		}
 		m := make(map[string]StringList, len(value.Content)/2)
-		// walk each matrix dimension
 		for j := 0; j < len(value.Content); j += 2 {
 			dim := value.Content[j].Value
 			listNode := value.Content[j+1]
+			// skip include/exclude (special GHA keys) and non-sequence dimensions
+			if dim == "include" || dim == "exclude" {
+				continue
+			}
 			if listNode.Kind != yaml.SequenceNode {
-				return fmt.Errorf("matrix.%s must be a sequence", dim)
+				continue
 			}
 			var items StringList
 			for _, item := range listNode.Content {
@@ -583,15 +607,15 @@ func (o *GithubActionsStrategy) UnmarshalYAML(node *yaml.Node) error {
 				case yaml.MappingNode:
 					var obj map[string]interface{}
 					if err := item.Decode(&obj); err != nil {
-						return fmt.Errorf("failed to decode matrix item: %w", err)
+						continue
 					}
 					b, err := json.Marshal(obj)
 					if err != nil {
-						return fmt.Errorf("failed to marshal matrix item: %w", err)
+						continue
 					}
 					items = append(items, string(b))
 				default:
-					return fmt.Errorf("unsupported node kind %v in matrix.%s", item.Kind, dim)
+					continue
 				}
 			}
 			m[dim] = items

models/github_actions_test.go

@@ -234,6 +234,50 @@ func TestGithubActionsWorkflowJobs(t *testing.T) {
 				},
 			},
 		},
+		{
+			Name:  "matrix with expression value",
+			Input: `example_matrix: { strategy: { matrix: "${{ fromJSON(needs.config.outputs.matrix) }}" } }`,
+			Expected: GithubActionsJob{
+				ID: "example_matrix",
+			},
+		},
+		{
+			Name:  "matrix with scalar dimension skipped",
+			Input: `example_matrix: { strategy: { matrix: { rust: stable, os: [ubuntu-latest, macos-latest] } } }`,
+			Expected: GithubActionsJob{
+				ID: "example_matrix",
+				Strategy: GithubActionsStrategy{
+					Matrix: map[string]StringList{
+						"os": {"ubuntu-latest", "macos-latest"},
+					},
+				},
+			},
+		},
+		{
+			Name:  "matrix with include and exclude skipped",
+			Input: `example_matrix: { strategy: { matrix: { os: [ubuntu-latest], include: [{ os: windows-latest, experimental: true }], exclude: [{ os: macos-latest }] } } }`,
+			Expected: GithubActionsJob{
+				ID: "example_matrix",
+				Strategy: GithubActionsStrategy{
+					Matrix: map[string]StringList{
+						"os": {"ubuntu-latest"},
+					},
+				},
+			},
+		},
+		{
+			Name:  "matrix with nested sequences skipped",
+			Input: "example_matrix:\n  strategy:\n    matrix:\n      target:\n        - [a, b]\n        - [c, d]\n      os: [ubuntu-latest]",
+			Expected: GithubActionsJob{
+				ID: "example_matrix",
+				Strategy: GithubActionsStrategy{
+					Matrix: map[string]StringList{
+						"target": nil,
+						"os":     {"ubuntu-latest"},
+					},
+				},
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -489,12 +533,12 @@ jobs:
 
 	assert.Equal(t, "workflow_call", workflow.Events[1].Name)
 	assert.Equal(t, "string", workflow.Events[1].Inputs[0].Type)
-	assert.Equal(t, true, workflow.Events[1].Inputs[0].Required)
+	assert.Equal(t, StringBool(true), workflow.Events[1].Inputs[0].Required)
 	assert.Equal(t, "build", workflow.Events[1].Outputs[0].Name)
 	assert.Equal(t, "build_id", workflow.Events[1].Outputs[0].Description)
 	assert.Equal(t, "${{ jobs.build.outputs.build }}", workflow.Events[1].Outputs[0].Value)
 	assert.Equal(t, "BOARD_TOKEN", workflow.Events[1].Secrets[0].Name)
-	assert.Equal(t, true, workflow.Events[1].Secrets[0].Required)
+	assert.Equal(t, StringBool(true), workflow.Events[1].Secrets[0].Required)
 
 	assert.Equal(t, "schedule", workflow.Events[2].Name)
 	assert.Equal(t, "0 0 * * 0", workflow.Events[2].Cron[0])
@@ -583,7 +627,7 @@ runs:
 	assert.Equal(t, "John Doe", actionMetadata.Author)
 	assert.Equal(t, "Analyze git sha", actionMetadata.Description)
 	assert.Equal(t, "git_sha", actionMetadata.Inputs[0].Name)
-	assert.Equal(t, true, actionMetadata.Inputs[0].Required)
+	assert.Equal(t, StringBool(true), actionMetadata.Inputs[0].Required)
 	assert.Equal(t, "string", actionMetadata.Inputs[0].Type)
 	assert.Equal(t, "response", actionMetadata.Outputs[0].Name)
 	assert.Equal(t, "Response from the command executed", actionMetadata.Outputs[0].Description)

models/gitlab.go

@@ -395,9 +395,8 @@ func (o *GitlabciStringRef) UnmarshalYAML(node *yaml.Node) error {
 		if node.Tag == "!reference" {
 			val, _ := yaml.Marshal(node)
 			*o = GitlabciStringRef(val)
-		} else {
-			return fmt.Errorf("unexpected string or reference")
 		}
+		// skip non-reference sequences
 	case yaml.ScalarNode:
 		var s string
 		if err := node.Decode(&s); err != nil {

scanner/parsers.go

@@ -1,7 +1,6 @@
 package scanner
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -18,7 +17,7 @@ type GithubActionsMetadataParser struct {
 
 func NewGithubActionsMetadataParser() *GithubActionsMetadataParser {
 	return &GithubActionsMetadataParser{
-		pattern: regexp.MustCompile(`(\b|/)action\.ya?ml$`),
+		pattern: regexp.MustCompile(`(^|/)action\.ya?ml$`),
 	}
 }
 
@@ -214,7 +213,8 @@ func (p *GitlabCiParser) Parse(filePath string, scanningPath string, pkgInsights
 func (p *GitlabCiParser) ParseFromMemory(data []byte, filePath string, pkgInsights *models.PackageInsights) error {
 	config, err := models.ParseGitlabciConfig(data)
 	if err != nil {
-		return fmt.Errorf("failed to parse gitlabci config: %w", err)
+		log.Debug().Err(err).Str("file", filePath).Msg("failed to parse gitlabci config")
+		return nil
 	}
 	config.Path = filePath