func()

in pkg/tasks/lint/validate.go [60:128]

• 48 lines of code
• 12 McCabe index (conditional complexity)

func (t *ValidateTask) Run(ctx context.Context) error {
	var (
		reader io.Reader
		err    error
	)

	// Create input reader
	reader, err = t.SourceReader(ctx)
	if err != nil {
		return fmt.Errorf("unable to read input reader: %w", err)
	}

	// Drain input reader
	payload, err := io.ReadAll(reader)
	if err != nil {
		return fmt.Errorf("unable to drain input reader: %w", err)
	}

	// Detect the appropriate schema
	if t.Schema == "" {
		// Decode as YAML any object
		var specBody fileSpec
		if errYaml := yaml.Unmarshal(payload, &specBody); errYaml != nil {
			return fmt.Errorf("unable to decode spec as YAML: %w", err)
		}

		// Check API Version
		if specBody.APIVersion != "harp.elastic.co/v1" {
			return fmt.Errorf("unsupported YAML file format '%s'", specBody.APIVersion)
		}

		// Assign detected kind
		t.Schema = specBody.Kind
	}

	// Select lint strategy
	s, ok := schemaRegistry[t.Schema]
	if !ok {
		return fmt.Errorf("unsupported schema definition for '%s'", t.Schema)
	}

	// Create output writer
	writer, err := t.OutputWriter(ctx)
	if err != nil {
		return fmt.Errorf("unable to open output bundle: %w", err)
	}

	// Display jsonschema
	if t.SchemaOnly {
		fmt.Fprintln(writer, string(s.Definition))
		return nil
	}

	// Execute the lint evaluation
	validationErrors, err := s.LintFunc(bytes.NewReader(payload))
	switch {
	case len(validationErrors) > 0:
		for _, e := range validationErrors {
			fmt.Fprintf(writer, " - %s\n", e.String())
		}
		return err
	case err != nil:
		return fmt.Errorf("unexpected validation error occurred: %w", err)
	default:
	}

	// No error
	return nil
}