func do()

in cmd/test2json2gha/main.go [66:134]
56 lines of code
11 McCabe index (conditional complexity)

func do(in io.Reader, out io.Writer, cfg config) (bool, error) {
	dec := json.NewDecoder(in)

	results := &resultsHandler{}
	defer results.Cleanup()

	defer func() {
		var wg waitGroup

		wg.Go(func() {
			var rf ResultsFormatter
			rf = &consoleFormatter{modName: cfg.modName, verbose: cfg.verbose}
			if err := rf.FormatResults(results.Results(), out); err != nil {
				slog.Error("Error writing annotations", "error", err)
			}

			rf = &errorAnnotationFormatter{}
			if err := rf.FormatResults(results.Results(), out); err != nil {
				slog.Error("Error writing error annotations", "error", err)
			}
		})

		wg.Go(func() {
			summary := getSummaryFile()
			formatter := &summaryFormatter{slowThreshold: cfg.slowThreshold}
			if err := formatter.FormatResults(results.Results(), getSummaryFile()); err != nil {
				slog.Error("Error writing summary", "error", err)
			}
			summary.Close()
		})

		wg.Wait()

		if cfg.logDir != "" {
			results.WriteLogs(cfg.logDir)
		}
	}()

	var anyFailed checkFailed
	handlers := []EventHandler{
		results,
		&anyFailed,
	}

	if cfg.stream {
		handlers = append(handlers, &outputStreamer{out: out})
	}

	te := &TestEvent{}
	for {
		*te = TestEvent{} // Reset the event struct to avoid reusing old data

		err := dec.Decode(te)
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return false, errors.WithStack(err)
		}

		for _, h := range handlers {
			if err := h.HandleEvent(te); err != nil {
				slog.Error("Error handling event", "error", err)
			}
		}
	}

	return bool(anyFailed), nil
}