package ci import ( "strconv" "strings" "gopkg.in/yaml.v3" ) func parseWorkflow(node *yaml.Node) ([]Rule, []Issue) { if node.Kind != yaml.MappingNode { return nil, []Issue{{Line: node.Line, Key: "ci.err.map"}} } var rules []Rule var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] if key == "rules" { parsed, iss := parseRules(val) issues = append(issues, iss...) rules = parsed continue } issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"workflow." + key}, Warning: true}) } return rules, issues } func parseRetry(node *yaml.Node) (Retry, []Issue) { switch node.Kind { case yaml.ScalarNode: n, iss := retryMax(node) if len(iss) > 0 && n == 0 && iss[0].Key != "ci.warn.retryMax" { return Retry{}, iss } return Retry{Max: n}, iss case yaml.MappingNode: var retry Retry var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "max": n, iss := retryMax(val) issues = append(issues, iss...) retry.Max = n case "when": list, iss := retryWhen(val) issues = append(issues, iss...) retry.When = list default: issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"retry." + key}, Warning: true}) } } return retry, issues default: return Retry{}, []Issue{{Line: node.Line, Key: "ci.err.retry"}} } } func retryMax(node *yaml.Node) (int, []Issue) { if node.Kind != yaml.ScalarNode { return 0, []Issue{{Line: node.Line, Key: "ci.err.retry"}} } n, err := strconv.Atoi(strings.TrimSpace(node.Value)) if err != nil || n < 0 { return 0, []Issue{{Line: node.Line, Key: "ci.err.retry"}} } if n > 2 { return 2, []Issue{{Line: node.Line, Key: "ci.warn.retryMax", Args: []any{n, 2}, Warning: true}} } return n, nil } func retryWhen(node *yaml.Node) ([]string, []Issue) { if node.Kind == yaml.ScalarNode { if strings.TrimSpace(node.Value) == "" { return nil, []Issue{{Line: node.Line, Key: "ci.err.retry"}} } return []string{node.Value}, nil } return scalarList(node, "ci.err.list") } func parseParallel(node *yaml.Node) (int, []MatrixSpec, []Issue) { if node.Kind == yaml.ScalarNode { n, err := strconv.Atoi(strings.TrimSpace(node.Value)) if err != nil || n < 1 { return 0, nil, []Issue{{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}} } if n > maxParallel { return 0, nil, []Issue{{Line: node.Line, Key: "ci.err.parallel", Args: []any{n, maxParallel}}} } return n, nil, nil } if node.Kind != yaml.MappingNode { return 0, nil, []Issue{{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}} } var specs []MatrixSpec var issues []Issue seen := false for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] if key != "matrix" { issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"parallel." + key}, Warning: true}) continue } seen = true parsed, iss := parseMatrix(val) issues = append(issues, iss...) specs = parsed } if !seen { issues = append(issues, Issue{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}) } count := 0 for _, spec := range specs { count += len(cartesian(spec)) } if count > maxParallel { issues = append(issues, Issue{Line: node.Line, Key: "ci.err.parallel", Args: []any{count, maxParallel}}) } return 0, specs, issues } func parseMatrix(node *yaml.Node) ([]MatrixSpec, []Issue) { if node.Kind != yaml.SequenceNode || len(node.Content) == 0 { return nil, []Issue{{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}} } var specs []MatrixSpec var issues []Issue for _, item := range node.Content { if item.Kind != yaml.MappingNode { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}) continue } spec := MatrixSpec{} for i := 0; i < len(item.Content); i += 2 { key := item.Content[i].Value vals, iss := matrixValues(item.Content[i+1]) issues = append(issues, iss...) if len(vals) == 0 { continue } spec.Keys = append(spec.Keys, key) spec.Vals = append(spec.Vals, vals) } if len(spec.Keys) == 0 { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}) continue } specs = append(specs, spec) } return specs, issues } func matrixValues(node *yaml.Node) ([]string, []Issue) { if node.Kind == yaml.ScalarNode { return []string{node.Value}, nil } return scalarList(node, "ci.err.list") } func parseServices(node *yaml.Node) ([]Service, []Issue) { var items []*yaml.Node switch node.Kind { case yaml.SequenceNode: items = node.Content default: items = []*yaml.Node{node} } var out []Service var issues []Issue for _, item := range items { switch item.Kind { case yaml.ScalarNode: if strings.TrimSpace(item.Value) == "" { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.service"}) continue } out = append(out, Service{Name: item.Value, Alias: serviceAlias(item.Value)}) case yaml.MappingNode: svc := Service{Variables: map[string]string{}} for i := 0; i < len(item.Content); i += 2 { key := item.Content[i].Value val := item.Content[i+1] switch key { case "name": if val.Kind == yaml.ScalarNode { svc.Name = val.Value } case "alias": if val.Kind == yaml.ScalarNode { svc.Alias = val.Value } case "command": list, iss := scriptList(val) issues = append(issues, iss...) svc.Command = list case "entrypoint": list, iss := scriptList(val) issues = append(issues, iss...) svc.Entrypoint = list case "variables": vars, iss := scalarMap(val) issues = append(issues, iss...) svc.Variables = vars default: issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"services." + key}, Warning: true}) } } if strings.TrimSpace(svc.Name) == "" { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.service"}) continue } if svc.Alias == "" { svc.Alias = serviceAlias(svc.Name) } out = append(out, svc) default: issues = append(issues, Issue{Line: item.Line, Key: "ci.err.service"}) } } return out, issues } func serviceAlias(image string) string { name := image if i := strings.LastIndex(name, "/"); i >= 0 { name = name[i+1:] } if i := strings.IndexAny(name, ":@"); i >= 0 { name = name[:i] } name = strings.TrimSpace(name) if name == "" { return "service" } return name } func parseEnvironment(node *yaml.Node) (Environment, []Issue) { switch node.Kind { case yaml.ScalarNode: if strings.TrimSpace(node.Value) == "" { return Environment{}, []Issue{{Line: node.Line, Key: "ci.err.environment"}} } return Environment{Name: node.Value}, nil case yaml.MappingNode: var env Environment var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "name": if val.Kind == yaml.ScalarNode { env.Name = val.Value } case "url": if val.Kind == yaml.ScalarNode { env.URL = val.Value } default: issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"environment." + key}, Warning: true}) } } if strings.TrimSpace(env.Name) == "" { issues = append(issues, Issue{Line: node.Line, Key: "ci.err.environment"}) } return env, issues default: return Environment{}, []Issue{{Line: node.Line, Key: "ci.err.environment"}} } }