func readScriptYaml()

in experiments/conductor/cmd/runner/mock_commands.go [178:300]
101 lines of code
22 McCabe index (conditional complexity)

func readScriptYaml(opts *RunnerOptions, branch Branch) {
	ctx := context.TODO()

	close := setLoggingWriter(opts, branch)
	defer close()
	if branch.Command == "" {
		log.Printf("SKIPPING %s, no gcloud command", branch.Name)
		return
	}

	workDir := filepath.Join(opts.branchRepoDir, "mockgcp")
	checkoutBranch(ctx, branch, workDir)

	// Check to see if the script file already exists
	scriptFile := fmt.Sprintf("mock%s/testdata/%s/crud/script.yaml", branch.Group, branch.Resource)
	scriptFullPath := filepath.Join(opts.branchRepoDir, "mockgcp", scriptFile)
	if _, err := os.Stat(scriptFullPath); errors.Is(err, os.ErrNotExist) {
		log.Printf("SKIPPING %s, %s doesn't exists", branch.Name, scriptFullPath)
		return
	}

	// Read and parse the script file
	data, err := os.ReadFile(scriptFullPath)
	if err != nil {
		log.Printf("Error reading file %s: %v", scriptFullPath, err)
		return
	}

	// Parse YAML content
	var scriptContent []map[string]string
	err = yaml.Unmarshal(data, &scriptContent)
	if err != nil {
		log.Printf("Error parsing YAML from %s: %v", scriptFullPath, err)
		return
	}

	// Check commands and collect warnings
	var warnings []string
	hasCreate := false
	hasDelete := false
	hasList := false

	for _, line := range scriptContent {
		if cmd, ok := line["exec"]; ok && strings.Contains(cmd, "gcloud") {
			if strings.Contains(cmd, " create ") {
				hasCreate = true
			}
			if strings.Contains(cmd, " delete ") {
				hasDelete = true
			}
			if strings.Contains(cmd, " list") {
				hasList = true
			}
		}
	}

	if !hasCreate {
		warning := "No Create found"
		warnings = append(warnings, warning)
		log.Printf("WARNING: %s in %s", warning, scriptFile)
	}
	if !hasDelete {
		warning := "No Delete found"
		warnings = append(warnings, warning)
		log.Printf("WARNING: %s in %s", warning, scriptFile)
	}
	if hasList {
		warning := "List found"
		warnings = append(warnings, warning)
		log.Printf("WARNING: %s in %s", warning, scriptFile)
	}

	// Read existing all_scripts.yaml or create new ScriptData
	allScriptsPath := filepath.Join(opts.loggingDir, "all_scripts.yaml")
	var scriptData ScriptData

	if data, err := os.ReadFile(allScriptsPath); err == nil {
		err = yaml.Unmarshal(data, &scriptData)
		if err != nil {
			log.Printf("Error parsing existing all_scripts.yaml: %v", err)
			return
		}
	}

	// Find and update existing branch or add new one
	newBranchScript := BranchScript{
		Name:        branch.Name,
		LocalBranch: branch.Local,
		Content:     scriptContent,
		Warnings:    warnings,
	}

	found := false
	for i, bs := range scriptData.Branches {
		if bs.Name == branch.Name {
			scriptData.Branches[i] = newBranchScript
			found = true
			break
		}
	}
	if !found {
		scriptData.Branches = append(scriptData.Branches, newBranchScript)
	}

	// Write updated data back to all_scripts.yaml
	yamlData, err := yaml.Marshal(scriptData)
	if err != nil {
		log.Printf("Error marshaling script data: %v", err)
		return
	}

	err = os.MkdirAll(opts.loggingDir, 0755)
	if err != nil {
		log.Printf("Error creating logs directory: %v", err)
		return
	}

	err = os.WriteFile(allScriptsPath, yamlData, 0644)
	if err != nil {
		log.Printf("Error writing all_scripts.yaml: %v", err)
		return
	}
}