Connect invocation execution to one reporter

execute.go

@@ -18,45 +18,59 @@ import (
 // nil context returns an operational failure, and nil streams are replaced with
 // io.Discard.
 func (a *App) Execute(ctx context.Context, args []string, streams Streams) Outcome {
-	if ctx == nil {
-		return a.present(Failure(errors.New("invocation context must not be nil")), nil, streams)
-	}
-	streams = normalizeStreams(streams)
 	current := newExecution(a, ctx, streams)
+	if a == nil {
+		err := errors.New("cannot execute commands on a nil app")
+		return current.finalize(Failure(err.Error()).WithCause(err), nil)
+	}
+	if ctx == nil {
+		err := errors.New("invocation context must not be nil")
+		return current.finalize(Failure(err.Error()).WithCause(err), nil)
+	}
 	routedSnapshot := current.snapshot
 	current.route = resolveEnteredRoute(args, routedSnapshot)
 	parsed := current.parse(current.route.args)
+	current.reporter.applySelection(parsed.Reporting)
+	var outcome Outcome
+	path := parsed.Path
 	if parsed.Failure != nil {
-		return current.present(Usage(errors.New(parsed.Failure.Message)), parsed.Path)
-	}
-	if current.route.kind == routeDiscovery {
+		outcome = Usage(parsed.Failure.Message)
+	} else if current.route.kind == routeDiscovery {
 		if parsed.HelpRequested {
-			return current.present(current.renderHelp(parsed.Path), clonePath(current.route.enteredPath))
+			outcome = current.renderHelp(parsed.Path)
+			path = clonePath(current.route.enteredPath)
+		} else {
+			entered := current.route.enteredPath.String()
+			outcome = Usage(fmt.Sprintf("incomplete command path %q; use %q --help", entered, entered))
+			path = clonePath(current.route.enteredPath)
 		}
-		entered := current.route.enteredPath.String()
-		return current.present(Usage(fmt.Errorf("incomplete command path %q; use %q --help", entered, entered)), clonePath(current.route.enteredPath))
-	}
-	payload, ok := routedSnapshot.runners[parsed.Key]
-	if !ok || payload == nil {
-		return current.present(current.renderHelp(parsed.Path), parsed.Path)
-	}
-	if parsed.HelpRequested || !payload.hasRun() {
-		if _, err := payload.prepare(parsed.FlagValues, parsed.FlagSpellings, parsed.Operands, false); err != nil {
-			return current.present(Usage(err), parsed.Path)
+	} else {
+		payload, ok := routedSnapshot.runners[parsed.Key]
+		if !ok || payload == nil {
+			outcome = current.renderHelp(parsed.Path)
+		} else if parsed.HelpRequested || !payload.hasRun() {
+			if _, err := payload.prepare(parsed.FlagValues, parsed.FlagSpellings, parsed.Operands, false); err != nil {
+				outcome = classifyInputError(err)
+			} else {
+				outcome = current.renderHelp(parsed.Path)
+			}
+		} else {
+			run, err := payload.prepare(parsed.FlagValues, parsed.FlagSpellings, parsed.Operands, true)
+			if err != nil {
+				outcome = classifyInputError(err)
+			} else {
+				outcome = run(current)
+			}
 		}
-		return current.present(current.renderHelp(parsed.Path), parsed.Path)
 	}
-	run, err := payload.prepare(parsed.FlagValues, parsed.FlagSpellings, parsed.Operands, true)
-	if err != nil {
-		return current.present(Usage(err), parsed.Path)
-	}
-	return current.present(run(current), parsed.Path)
+	return current.finalize(outcome, path)
 }
 
 type execution struct {
 	app      *App
 	ctx      context.Context
 	streams  Streams
+	reporter *Reporter
 	options  commandmeta.ParseOptions
 	snapshot *routingSnapshot
 	session  *internalcobra.Session
@@ -78,7 +92,7 @@ func (current *execution) commandContext() commandExecution {
 func (current *execution) invocation() Invocation {
 	return Invocation{
 		Context:       current.ctx,
-		Streams:       current.streams,
+		reporter:      current.reporter,
 		enteredPath:   current.route.enteredPath.String(),
 		canonicalPath: current.route.canonicalPath.String(),
 	}
@@ -89,11 +103,13 @@ func (current commandExecution) renderHelpTargets(targets []string) Outcome {
 }
 
 func newExecution(app *App, ctx context.Context, streams Streams) *execution {
+	streams = normalizeStreams(streams)
 	current := &execution{
-		app:     app,
-		ctx:     ctx,
-		streams: streams,
-		options: commandmeta.ParseOptions{Context: ctx, Out: streams.Out, Err: streams.Err},
+		app:      app,
+		ctx:      ctx,
+		streams:  streams,
+		reporter: newReporter(streams),
+		options:  commandmeta.ParseOptions{Context: ctx, Out: streams.Out, Err: streams.Err},
 	}
 	if app != nil {
 		current.snapshot = app.routeSnapshot()
@@ -108,7 +124,7 @@ func (current *execution) parse(args []string) commandmeta.Result {
 	if current.session == nil {
 		current.prepareSession()
 	}
-	return current.session.Parse(args)
+	return reduceReportingOccurrences(current.session.Parse(args))
 }
 
 func (current *execution) prepareSession() {
@@ -145,7 +161,8 @@ func (current *execution) presentationSession() *internalcobra.Session {
 
 func (current *execution) renderHelp(path []string) Outcome {
 	if current.app == nil {
-		return Failure(errors.New("cannot render help on a nil app"))
+		err := errors.New("cannot render help on a nil app")
+		return Failure(err.Error()).WithCause(err)
 	}
 	session := current.presentationSession()
 	view := current.app.helpView(current.route, current.snapshot)
@@ -154,11 +171,13 @@ func (current *execution) renderHelp(path []string) Outcome {
 
 func (current *execution) renderHelpTargets(targets []string) Outcome {
 	if current.app == nil {
-		return Failure(errors.New("cannot render help on a nil app"))
+		err := errors.New("cannot render help on a nil app")
+		return Failure(err.Error()).WithCause(err)
 	}
 	snapshot := current.app.routeSnapshot()
 	if snapshot == nil {
-		return Failure(errors.New("cannot render help without command metadata"))
+		err := errors.New("cannot render help without command metadata")
+		return Failure(err.Error()).WithCause(err)
 	}
 	route := resolveEnteredRoute(targets, snapshot)
 	// Explicit help targets are paths, not command invocations with operands.
@@ -192,21 +211,6 @@ func (current *execution) usageLine(path []string) string {
 	return current.app.usageFallback()
 }
 
-func (current *execution) present(outcome Outcome, path []string) Outcome {
-	usageLine := func(path []string) string { return current.usageLine(path) }
-	switch {
-	case current.route.kind == routeDiscovery:
-		path = clonePath(current.route.enteredPath)
-		usageLine = func([]string) string {
-			return fmt.Sprintf("Usage: %s %s [command]", current.app.identity.Name, current.route.enteredPath.String())
-		}
-	case current.route.kind == routeCanonical && !current.route.enteredPath.Equal(current.route.canonicalPath):
-		path = clonePath(current.route.enteredPath)
-		usageLine = func([]string) string { return current.routeUsageLine() }
-	}
-	return current.app.presentWithUsageLine(outcome, path, current.streams, usageLine)
-}
-
 func (current *execution) routeUsageLine() string {
 	line := current.usageLine(clonePath(current.route.canonicalPath))
 	canonical := strings.TrimSpace(current.app.identity.Name + " " + current.route.canonicalPath.String())
@@ -215,57 +219,31 @@ func (current *execution) routeUsageLine() string {
 	return line + "\nAlias for: " + canonical
 }
 
-func (a *App) present(outcome Outcome, path []string, streams Streams) Outcome {
-	return a.presentWithUsageLine(outcome, path, streams, a.usageLine)
+func (current *execution) finalize(outcome Outcome, path []string) Outcome {
+	if outcome.Kind == OutcomeUsage {
+		details := append([]Detail(nil), outcome.Explanation.Details...)
+		details = append(details, func(w io.Writer) error {
+			line := current.usageText(path)
+			if !strings.HasSuffix(line, "\n") {
+				line += "\n"
+			}
+			_, err := io.WriteString(w, line)
+			return err
+		})
+		outcome.Explanation.Details = details
+	}
+	return current.reporter.finalize(outcome, nil)
 }
 
-func (a *App) presentWithUsageLine(outcome Outcome, path []string, streams Streams, usageLine func([]string) string) Outcome {
-	if outcome.Kind == "" && outcome.Status == 0 && outcome.Domain == "" &&
-		outcome.Cause == nil && outcome.DeliveryError == nil &&
-		!outcome.ReportIncomplete && len(outcome.Diagnostics) == 0 {
-		outcome.Kind = OutcomeSuccess
+func (current *execution) usageText(path []string) string {
+	switch {
+	case current.route.kind == routeDiscovery && current.app != nil:
+		return fmt.Sprintf("Usage: %s %s [command]", current.app.identity.Name, current.route.enteredPath.String())
+	case current.route.kind == routeCanonical && !current.route.enteredPath.Equal(current.route.canonicalPath):
+		return current.routeUsageLine()
+	default:
+		return current.usageLine(path)
 	}
-	if outcome.DiagnosticDelivery == "" {
-		outcome.DiagnosticDelivery = DeliveryNone
-	}
-	streams = normalizeStreams(streams)
-	if outcome.DiagnosticDelivery == DeliveryComplete {
-		return outcome
-	}
-	diagnostics := append([]Diagnostic(nil), outcome.Diagnostics...)
-	if outcome.Cause != nil && !hasErrorDiagnostic(diagnostics) {
-		diagnostics = append(diagnostics, MessageDiagnostic(SeverityError, outcome.Cause.Error()))
-	}
-	if outcome.Kind == OutcomeUsage {
-		diagnostics = append(diagnostics, MessageDiagnostic(SeverityError, usageLine(path)))
-	}
-	outcome.Diagnostics = diagnostics
-	if len(diagnostics) == 0 {
-		return outcome
-	}
-	delivered := false
-	for _, diagnostic := range diagnostics {
-		if diagnostic.Write == nil {
-			continue
-		}
-		delivered = true
-		writer := &checkedWriter{writer: streams.Err}
-		writeErr := diagnostic.Write(writer)
-		if writer.failure != nil {
-			if writeErr == nil {
-				writeErr = writer.failure
-			} else if !errors.Is(writeErr, writer.failure) {
-				writeErr = errors.Join(writeErr, writer.failure)
-			}
-		}
-		if writeErr != nil {
-			return deliveryFailure(outcome, writeErr)
-		}
-	}
-	if delivered {
-		outcome.DiagnosticDelivery = DeliveryComplete
-	}
-	return outcome
 }
 
 func (a *App) usageLine(path []string) string {
@@ -284,42 +262,3 @@ func (a *App) usageFallback() string {
 	}
 	return fmt.Sprintf("Usage: %s [command]", name)
 }
-
-func hasErrorDiagnostic(diagnostics []Diagnostic) bool {
-	for _, diagnostic := range diagnostics {
-		if diagnostic.Write != nil && diagnostic.Severity == SeverityError {
-			return true
-		}
-	}
-	return false
-}
-
-func deliveryFailure(outcome Outcome, err error) Outcome {
-	if outcome.DeliveryError == nil {
-		outcome.DeliveryError = err
-	} else {
-		outcome.DeliveryError = errors.Join(outcome.DeliveryError, err)
-	}
-	outcome.DiagnosticDelivery = DeliveryIncomplete
-	if outcome.Kind != OutcomeDomain {
-		outcome.Kind = OutcomeOperational
-		outcome.Status = 1
-	}
-	return outcome
-}
-
-type checkedWriter struct {
-	writer  io.Writer
-	failure error
-}
-
-func (w *checkedWriter) Write(data []byte) (int, error) {
-	n, err := w.writer.Write(data)
-	if err == nil && n < len(data) {
-		err = io.ErrShortWrite
-	}
-	if err != nil && w.failure == nil {
-		w.failure = err
-	}
-	return n, err
-}