116 lines
3.1 KiB
Go
116 lines
3.1 KiB
Go
package bonfire
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"slices"
|
|
"strings"
|
|
|
|
"charm.land/lipgloss/v2"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
// Exit codes returned by Execute and Fail.
|
|
const (
|
|
// ExitOK means the command succeeded.
|
|
ExitOK = 0
|
|
// ExitFailure means the command failed.
|
|
ExitFailure = 1
|
|
// ExitUsage means the command was called wrongly: an unknown command or
|
|
// flag, or a wrong number of arguments.
|
|
ExitUsage = 2
|
|
)
|
|
|
|
// Execute runs root with args and returns the process exit code: ExitOK,
|
|
// ExitFailure, ExitUsage for usage errors, or the code an error carries
|
|
// through WithExitCode. With no command word in args (only global options,
|
|
// -h or --help) it prints the command list. Errors are rendered on the
|
|
// root's error stream by RenderError. Execute leaves the root's help
|
|
// function alone, and on Windows enables ANSI processing on the output and
|
|
// error streams when they are files (a no-op elsewhere).
|
|
func Execute(ctx context.Context, root *cobra.Command, args []string) int {
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
if args == nil {
|
|
// cobra reads os.Args when the args are nil.
|
|
args = []string{}
|
|
}
|
|
g := PeekGlobals(args)
|
|
if !hasCommandWord(args) {
|
|
args = slices.DeleteFunc(slices.Clone(args), func(a string) bool {
|
|
return a == "-h" || a == "--help"
|
|
})
|
|
}
|
|
resetFlags(root)
|
|
root.SetArgs(args)
|
|
// The settings fang applied; NewRootIO sets them already, a root built
|
|
// elsewhere gets them here.
|
|
root.SilenceUsage = true
|
|
root.SilenceErrors = true
|
|
root.CompletionOptions.DisableDefaultCmd = true
|
|
for _, w := range []io.Writer{root.OutOrStdout(), root.ErrOrStderr()} {
|
|
if f, ok := w.(*os.File); ok {
|
|
lipgloss.EnableLegacyWindowsANSI(f)
|
|
}
|
|
}
|
|
err := root.ExecuteContext(ctx)
|
|
if err == nil {
|
|
return ExitOK
|
|
}
|
|
err = unknownCommand(root, args, err)
|
|
name := root.Name()
|
|
RenderError(root.ErrOrStderr(), name, wrongDirectory(name, err, args, ""), g)
|
|
return exitCode(err)
|
|
}
|
|
|
|
// Fail renders err like Execute does and returns ExitFailure (ExitOK for a
|
|
// nil error). The generated main uses it for errors that happen before the
|
|
// command root exists, such as a configuration that does not load. Like
|
|
// Execute, it adds the wrong-directory hint for an application binary run
|
|
// outside its application root.
|
|
func Fail(w io.Writer, name string, err error, g Globals) int {
|
|
if err == nil {
|
|
return ExitOK
|
|
}
|
|
RenderError(w, name, wrongDirectory(name, err, os.Args[1:], ""), g)
|
|
return ExitFailure
|
|
}
|
|
|
|
func exitCode(err error) int {
|
|
var carrier *exitCodeError
|
|
switch {
|
|
case err == nil:
|
|
return ExitOK
|
|
case errors.As(err, &carrier):
|
|
if carrier.code < 1 || carrier.code > 255 {
|
|
return ExitFailure
|
|
}
|
|
return carrier.code
|
|
case isUsage(err):
|
|
return ExitUsage
|
|
default:
|
|
return ExitFailure
|
|
}
|
|
}
|
|
|
|
// hasCommandWord reports whether args, before "--", hold a token that is
|
|
// neither a flag nor the value of --env.
|
|
func hasCommandWord(args []string) bool {
|
|
for i := 0; i < len(args); i++ {
|
|
a := args[i]
|
|
switch {
|
|
case a == "--":
|
|
return false
|
|
case a == "--"+flagEnv:
|
|
i++
|
|
case strings.HasPrefix(a, "-"):
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|